Reuse schema properties

[llermaly]

Hi,

I have a very large schema that represents a cluster with many data tiers:

hot
warm
cold
frozen

Each of this properties contains a "node" type. I can't figure out how can I reuse this node type to avoid repeating.

const nodesOut = z.object({
  zone: z.string(),
  hot: z.array(
    z.object({
      jvm: z.object({
        mem: z.object({
          heap_used_in_bytes: z.number(),
          heap_used_percent: z.number(),
        }),
      }),
      fs: z.object({
        total: z.object({
          total_in_bytes: z.number(),
          free_in_bytes: z.number(),
          available_in_bytes: z.number(),
        }),
      }),
      indices: z.object({
        mappings: z.object({
          total_count: z.number(),
          total_estimated_overhead_in_bytes: z.number(),
        }),
      }).optional(),
      attributes: z.object({
        data: z.string().optional(),
        availability_zone: z.string(),
        server_name: z.string(),
      }),
    })
  ).optional(),
  warm: z.array(
    z.object({
      jvm: z.object({
        mem: z.object({
          heap_used_in_bytes: z.number(),
          heap_used_percent: z.number(),
        }),
      }),
      fs: z.object({
        total: z.object({
          total_in_bytes: z.number(),
          free_in_bytes: z.number(),
          available_in_bytes: z.number(),
        }),
      }),
      indices: z.object({
        mappings: z.object({
          total_count: z.number(),
          total_estimated_overhead_in_bytes: z.number(),
        }),
      }).optional(),
      attributes: z.object({
        data: z.string().optional(),
        availability_zone: z.string(),
        server_name: z.string(),
      }),
    })
  ).optional(),
  cold: z.array(
    z.object({
      jvm: z.object({
        mem: z.object({
          heap_used_in_bytes: z.number(),
          heap_used_percent: z.number(),
        }),
      }),
      fs: z.object({
        total: z.object({
          total_in_bytes: z.number(),
          free_in_bytes: z.number(),
          available_in_bytes: z.number(),
        }),
      }),
      indices: z.object({
        mappings: z.object({
          total_count: z.number(),
          total_estimated_overhead_in_bytes: z.number(),
        }).optional(),
      }),
      attributes: z.object({
        data: z.string().optional(),
        availability_zone: z.string(),
        server_name: z.string(),
      }),
    })
  ).optional(),
  frozen: z.array(
    z.object({
      jvm: z.object({
        mem: z.object({
          heap_used_in_bytes: z.number(),
          heap_used_percent: z.number(),
        }),
      }),
      fs: z.object({
        total: z.object({
          total_in_bytes: z.number(),
          free_in_bytes: z.number(),
          available_in_bytes: z.number(),
        }),
      }),
      indices: z.object({
        mappings: z.object({
          total_count: z.number(),
          total_estimated_overhead_in_bytes: z.number(),
        }),
      }).optional(),
      attributes: z.object({
        data: z.string().optional(),
        availability_zone: z.string(),
        server_name: z.string(),
      }),
    })
  ).optional(),
});

I read about recursive schemas but this is not actually recursive. What's the best way to go?

Thanks

[JacobWeisenburger]

Does this help?

const jvmSchema = z.object( {
    mem: z.object( {
        heap_used_in_bytes: z.number(),
        heap_used_percent: z.number(),
    } ),
} )

const fsSchema = z.object( {
    total: z.object( {
        total_in_bytes: z.number(),
        free_in_bytes: z.number(),
        available_in_bytes: z.number(),
    } ),
} )

const indicesSchema = z.object( {
    mappings: z.object( {
        total_count: z.number(),
        total_estimated_overhead_in_bytes: z.number(),
    } ),
} )

const attributesSchema = z.object( {
    data: z.string().optional(),
    availability_zone: z.string(),
    server_name: z.string(),
} )

const schema = z.object( {
    jvm: jvmSchema,
    fs: fsSchema,
    indices: indicesSchema.optional(),
    attributes: attributesSchema,
} )

const nodesOut = z.object( {
    zone: z.string(),
    hot: z.array( schema ).optional(),
    warm: z.array( schema ).optional(),
    cold: z.array( schema ).optional(),
    frozen: z.array( schema ).optional(),
} )

[llermaly]

Thank you very much!

I ended up with this:

const node = z.object({
  jvm: z.object({
    mem: z.object({
      heap_used_in_bytes: z.number(),
      heap_used_percent: z.number(),
    }),
  }),
  fs: z.object({
    total: z.object({
      total_in_bytes: z.number(),
      free_in_bytes: z.number(),
      available_in_bytes: z.number(),
    }),
  }),
  indices: z
    .object({
      mappings: z
        .object({
          total_count: z.number(),
          total_estimated_overhead_in_bytes: z.number(),
        })
        .optional(),
    })
    .optional(),
  attributes: z.object({
    data: z.string(),
    availability_zone: z.string(),
    server_name: z.string(),
    logical_availability_zone: z.string(),
  }),
});

const nodesIn = z.object({
  nodes: node,
  cluster_name: z.string(),
});

const nodesOut = z.object({
  zone: z.string(),
  hot: z.array(node).optional(),
  warm: z.array(node).optional(),
  cold: z.array(node).optional(),
  frozen: z.array(node).optional(),
});

type NodesInType = z.TypeOf<typeof nodesIn>;
type NodesOutType = z.TypeOf<typeof nodesOut>;

Thing is now code is complaining here:

const clusterState = (input: NodesInType) => {
  // Drop documents that don't have attribute.data  (e.g master nodes)
  const dataNodes = Object.entries(input.nodes)
    .map(([, value]) => value)
    .filter(
      (node) =>
        node.attributes.data &&
        node.attributes.logical_availability_zone !== "tiebreaker"
    );

Property 'attributes' does not exist on type '{ mem: { heap_used_in_bytes: number; heap_used_percent: number; }; } | { total: { total_in_bytes: number; free_in_bytes: number; available_in_bytes: number; }; } | { mappings?: { total_count: number; total_estimated_overhead_in_bytes: number; } | undefined; } | { ...; }'.
  Property 'attributes' does not exist on type '{ mem: { heap_used_in_bytes: number; heap_used_percent: number; }; }'.ts(2339)

[llermaly]

I made this change and now it works:

const nodesIn = z.object({
   nodes: z.record(node),
});