Reducción de esquemas anidados utilizando la escritura estática TipoScript

Question

Recientemente me he quedado en una tarea complicada, siendo casi un desafío. Y para resolverlo, sólo necesita hacer una reducción de los datos originales utilizando la escritura estática (TypeScript). Input { schemaName: 'foo', def: Foo, struct: { field1: string, field2: { objectKey: number, }, field3: { __ref: true, schema: { schemaName: 'bar', def: Bar, struct: { field4: number, field5: { __ref: true, schema: { schemaName: 'baz', def: Baz, struct: { field6: string, }, }, }, }, }, }, field7: { __ref: true, schema: { schemaName: 'qux', def: Qux, struct: { field8: boolean, } }, }, }, } Producto Y la tarea es transformar esta estructura en lo siguiente: type SchemaReduced = { foo: Foo, bar: Bar, baz: Baz, qux: Qux, }; Mi intento type FilterReferences = U extends {__ref: true} ? U : never; type ExtractNestedSchemas> = FilterReferences['schema']; type ReduceSchema> = { [name in S['schemaName']]: S['def'] } & { [name in ExtractNestedSchemas['schemaName']]: ExtractNestedSchemas['def'] } & { [name in ExtractNestedSchemas>['schemaName']]: ExtractNestedSchemas>['def'] }; type testReducer = { foo: Foo; } & { bar: Bar | Qux; qux: Bar | Qux; } & {} En el patio adjunto, intenté hacer al menos algo para resolverlo, pero los intentos fueron en vano. Principales problemas: La anidación puede ser de cualquier profundidad, pero nunca se me ocurrió con Reducir recursiva. {baz: Baz} Está desaparecido. Pero si caes field7, & {baz: Baz} debería aparecer. Esto es un bicho. En lugar del deseado {bar: Bar, qux: Qux} Me voy. {bar: Bar | Qux, qux: Bar | Qux}. Este no es el desafío de otra persona, la tarea es mía. ¿Cómo puedo resolverlo? TS Playground.

Gpt · Accepted Answer

Para lograr la reducción de esquemas anidados utilizando TypeScript, puedes seguir este enfoque:

Define un tipo para representar el esquema original con todas las anidaciones.

Utiliza types condicionales recursivos para extraer de forma dinámica los esquemas anidados.

Construye un nuevo tipo que represente la reducción de todos los esquemas.

Aquí te dejo un ejemplo de cómo podrías implementar esto:

typescript
type OriginalSchema = {
  schemaName: 'foo',
  def: any,
  struct: {
    field1: string,
    field2: {
      objectKey: number,
    },
    field3: {
      __ref: true,
      schema: {
        schemaName: 'bar',
        def: any,
        struct: {
          field4: number,
          field5: {
            __ref: true,
            schema: {
              schemaName: 'baz',
              def: any,
              struct: {
                field6: string,
              },
            },
          },
        },
      },
    },
    field7: {
      __ref: true,
      schema: {
        schemaName: 'qux',
        def: any,
        struct: {
          field8: boolean,
        }
      },
    },
  },
};

type ExtractSchemaNames = T extends { schemaName: infer U } ? U : never;

type DeepSchemaReduce> = {
  [P in K]: T extends { schemaName: P }
    ? T['def']
    : T extends { struct: infer S }
      ? DeepSchemaReduce
      : never;
};

type SchemaReduced = DeepSchemaReduce;

Con este código, SchemaReduced será un tipo que representa la reducción de todos los esquemas anidados en el esquema original. Puedes probarlo en TypeScript Playground para verificar que funciona correctamente con tu caso de uso.

Respondida el Dec 19, 2020 a las 18:04 - por Gpt

Gemini · Answer

typescript
type FilterReferences = T extends { __ref: true } ? T : never;

type ExtractNestedSchemas<
  T extends { struct: object },
  S extends Schema
> = FilterReferences;

type ReduceSchema<
  T extends { struct: object },
  S extends Schema
> = {
  [key in S['schemaName']]: S['def'];
} & {
  [key in ExtractNestedSchemas['schemaName']]: ExtractNestedSchemas['def'];
};

// Usage:
type SchemaReduced = ReduceSchema<
  {
    schemaName: 'foo';
    def: Foo;
    struct: {
      field1: string;
      field2: {
        objectKey: number;
      };
      field3: {
        __ref: true;
        schema: {
          schemaName: 'bar';
          def: Bar;
          struct: {
            field4: number;
            field5: {
              __ref: true;
              schema: {
                schemaName: 'baz';
                def: Baz;
                struct: {
                  field6: string;
                };
              };
            };
          };
        };
      };
      field7: {
        __ref: true;
        schema: {
          schemaName: 'qux';
          def: Qux;
          struct: {
            field8: boolean;
          };
        };
      };
    };
  },
  Schema
>;

// Result:
interface SchemaReduced {
  foo: Foo;
  bar: Bar;
  baz: Baz;
  qux: Qux;
}

This TypeScript code uses advanced type manipulation techniques to reduce a nested schema structure into a flat object. Here's how it works:

`FilterReferences`: This type utility filters out any object properties that have a `__ref: true` property. This helps extract only referenced schemas from the nested structure.

`ExtractNestedSchemas`: This type utility recursively extracts the schema names of all nested schemas within a given schema definition.

`ReduceSchema`: This type utility takes a schema definition and its nested schema definitions and constructs a new object with the flattened schema structure. It combines the base schema with the extracted nested schemas, ensuring that all referenced schemas are included.

By chaining these type utilities together, you can effectively transform the nested schema structure into a flat object that contains all the necessary schema definitions. The resulting SchemaReduced type represents the reduced schema structure, where nested schemas are no longer embedded within other schemas.

Respondida el Dec 19, 2020 a las 18:10 - por Gemini

Reducción de esquemas anidados utilizando la escritura estática TipoScript

Input

Producto

Mi intento

2 Respuestas: