@bairock/lenz 0.0.16 → 0.0.17

package/dist/engine/generators/SDLInputTypesGenerator.js

@@ -0,0 +1,763 @@
+// ===== Helpers =====
+function isEnum(type, enums) {
+    return enums.some(e => e.name === type);
+}
+function getFilterName(type, isRequired, enums) {
+    if (isEnum(type, enums))
+        return isRequired ? `Enum${type}Filter` : `Enum${type}NullableFilter`;
+    switch (type) {
+        case 'String': return isRequired ? 'StringFilter' : 'StringNullableFilter';
+        case 'Int': return isRequired ? 'IntFilter' : 'IntNullableFilter';
+        case 'Float': return isRequired ? 'FloatFilter' : 'FloatNullableFilter';
+        case 'Boolean': return isRequired ? 'BooleanFilter' : 'BooleanNullableFilter';
+        case 'DateTime':
+        case 'Date': return isRequired ? 'DateTimeFilter' : 'DateTimeNullableFilter';
+        case 'ID': return 'IDFilter';
+        case 'Json': return 'JsonFilter';
+        case 'BigInt': return isRequired ? 'BigIntFilter' : 'BigIntNullableFilter';
+        case 'Bytes': return isRequired ? 'BytesFilter' : 'BytesNullableFilter';
+        case 'ObjectId': return isRequired ? 'StringFilter' : 'StringNullableFilter';
+        default: return isRequired ? 'StringFilter' : 'StringNullableFilter';
+    }
+}
+function getWithAggregatesFilterName(type, isRequired, enums) {
+    if (isEnum(type, enums))
+        return isRequired ? `Enum${type}WithAggregatesFilter` : `Enum${type}NullableWithAggregatesFilter`;
+    switch (type) {
+        case 'String': return isRequired ? 'StringWithAggregatesFilter' : 'StringNullableWithAggregatesFilter';
+        case 'Int': return isRequired ? 'IntWithAggregatesFilter' : 'IntNullableWithAggregatesFilter';
+        case 'Float': return isRequired ? 'FloatWithAggregatesFilter' : 'FloatNullableWithAggregatesFilter';
+        case 'Boolean': return isRequired ? 'BooleanWithAggregatesFilter' : 'BooleanNullableWithAggregatesFilter';
+        case 'DateTime':
+        case 'Date': return isRequired ? 'DateTimeWithAggregatesFilter' : 'DateTimeNullableWithAggregatesFilter';
+        case 'ID': return 'IDFilter';
+        case 'Json': return 'JsonFilter';
+        case 'BigInt': return isRequired ? 'BigIntWithAggregatesFilter' : 'BigIntNullableWithAggregatesFilter';
+        case 'Bytes': return isRequired ? 'BytesWithAggregatesFilter' : 'BytesNullableWithAggregatesFilter';
+        case 'ObjectId': return isRequired ? 'StringWithAggregatesFilter' : 'StringNullableWithAggregatesFilter';
+        default: return isRequired ? 'StringWithAggregatesFilter' : 'StringNullableWithAggregatesFilter';
+    }
+}
+function getArrayFilterName(type) {
+    switch (type) {
+        case 'String': return 'StringArrayFilter';
+        case 'Int': return 'IntArrayFilter';
+        case 'Float': return 'FloatArrayFilter';
+        case 'Boolean': return 'BooleanArrayFilter';
+        case 'DateTime':
+        case 'Date': return 'DateTimeArrayFilter';
+        case 'BigInt': return 'BigIntArrayFilter';
+        case 'Bytes': return 'BytesArrayFilter';
+        default: return 'StringArrayFilter';
+    }
+}
+// ===== SDL Snippets =====
+function sdlScalars() {
+    return 'scalar DateTime';
+}
+function sdlBatchPayload() {
+    return 'type BatchPayload {\n  count: Int!\n}';
+}
+function sdlSortEnums() {
+    return `enum SortOrder {
+  asc
+  desc
+}
+
+enum QueryMode {
+  default
+  insensitive
+}
+
+enum NullsOrder {
+  first
+  last
+}`;
+}
+function sdlSortOrderInput() {
+    return `input SortOrderInput {
+  sort: SortOrder!
+  nulls: NullsOrder
+}`;
+}
+function sdlBaseFilters() {
+    return `input StringFilter {
+  equals: String
+  not: String
+  in: [String!]
+  notIn: [String!]
+  lt: String
+  lte: String
+  gt: String
+  gte: String
+  contains: String
+  startsWith: String
+  endsWith: String
+  mode: QueryMode
+}
+
+input StringNullableFilter {
+  equals: String
+  not: String
+  in: [String!]
+  notIn: [String!]
+  lt: String
+  lte: String
+  gt: String
+  gte: String
+  contains: String
+  startsWith: String
+  endsWith: String
+  mode: QueryMode
+}
+
+input IntFilter {
+  equals: Int
+  not: Int
+  in: [Int!]
+  notIn: [Int!]
+  lt: Int
+  lte: Int
+  gt: Int
+  gte: Int
+}
+
+input IntNullableFilter {
+  equals: Int
+  not: Int
+  in: [Int!]
+  notIn: [Int!]
+  lt: Int
+  lte: Int
+  gt: Int
+  gte: Int
+}
+
+input FloatFilter {
+  equals: Float
+  not: Float
+  in: [Float!]
+  notIn: [Float!]
+  lt: Float
+  lte: Float
+  gt: Float
+  gte: Float
+}
+
+input FloatNullableFilter {
+  equals: Float
+  not: Float
+  in: [Float!]
+  notIn: [Float!]
+  lt: Float
+  lte: Float
+  gt: Float
+  gte: Float
+}
+
+input BooleanFilter {
+  equals: Boolean
+  not: Boolean
+}
+
+input BooleanNullableFilter {
+  equals: Boolean
+  not: Boolean
+}
+
+input DateTimeFilter {
+  equals: DateTime
+  not: DateTime
+  in: [DateTime!]
+  notIn: [DateTime!]
+  lt: DateTime
+  lte: DateTime
+  gt: DateTime
+  gte: DateTime
+}
+
+input DateTimeNullableFilter {
+  equals: DateTime
+  not: DateTime
+  in: [DateTime!]
+  notIn: [DateTime!]
+  lt: DateTime
+  lte: DateTime
+  gt: DateTime
+  gte: DateTime
+}
+
+input IDFilter {
+  equals: String
+  not: String
+  in: [String!]
+  notIn: [String!]
+}
+
+input JsonFilter {
+  equals: JSON
+  not: JSON
+  path: [String!]
+  string_contains: String
+  string_starts_with: String
+  string_ends_with: String
+  array_contains: JSON
+  array_starts_with: JSON
+  array_ends_with: JSON
+}
+
+input BigIntFilter {
+  equals: BigInt
+  not: BigInt
+  in: [BigInt!]
+  notIn: [BigInt!]
+  lt: BigInt
+  lte: BigInt
+  gt: BigInt
+  gte: BigInt
+}
+
+input BigIntNullableFilter {
+  equals: BigInt
+  not: BigInt
+  in: [BigInt!]
+  notIn: [BigInt!]
+  lt: BigInt
+  lte: BigInt
+  gt: BigInt
+  gte: BigInt
+}
+
+input BytesFilter {
+  equals: Bytes
+  not: Bytes
+  in: [Bytes!]
+  notIn: [Bytes!]
+}
+
+input BytesNullableFilter {
+  equals: Bytes
+  not: Bytes
+  in: [Bytes!]
+  notIn: [Bytes!]
+}`;
+}
+function sdlArrayFilters() {
+    return `input StringArrayFilter {
+  has: String
+  hasEvery: [String!]
+  hasSome: [String!]
+  isEmpty: Boolean
+  equals: [String!]
+}
+
+input IntArrayFilter {
+  has: Int
+  hasEvery: [Int!]
+  hasSome: [Int!]
+  isEmpty: Boolean
+  equals: [Int!]
+}
+
+input FloatArrayFilter {
+  has: Float
+  hasEvery: [Float!]
+  hasSome: [Float!]
+  isEmpty: Boolean
+  equals: [Float!]
+}
+
+input DateTimeArrayFilter {
+  has: DateTime
+  hasEvery: [DateTime!]
+  hasSome: [DateTime!]
+  isEmpty: Boolean
+  equals: [DateTime!]
+}
+
+input BigIntArrayFilter {
+  has: BigInt
+  hasEvery: [BigInt!]
+  hasSome: [BigInt!]
+  isEmpty: Boolean
+  equals: [BigInt!]
+}
+
+input BytesArrayFilter {
+  has: Bytes
+  hasEvery: [Bytes!]
+  hasSome: [Bytes!]
+  isEmpty: Boolean
+  equals: [Bytes!]
+}`;
+}
+function sdlWithAggregatesFilters() {
+    return `input StringWithAggregatesFilter {
+  equals: String
+  not: String
+  in: [String!]
+  notIn: [String!]
+  lt: String
+  lte: String
+  gt: String
+  gte: String
+  contains: String
+  startsWith: String
+  endsWith: String
+  mode: QueryMode
+  _count: IntFilter
+  _min: StringFilter
+  _max: StringFilter
+}
+
+input StringNullableWithAggregatesFilter {
+  equals: String
+  not: String
+  in: [String!]
+  notIn: [String!]
+  lt: String
+  lte: String
+  gt: String
+  gte: String
+  contains: String
+  startsWith: String
+  endsWith: String
+  mode: QueryMode
+  _count: IntFilter
+  _min: StringFilter
+  _max: StringFilter
+}
+
+input IntWithAggregatesFilter {
+  equals: Int
+  not: Int
+  in: [Int!]
+  notIn: [Int!]
+  lt: Int
+  lte: Int
+  gt: Int
+  gte: Int
+  _count: IntFilter
+  _avg: FloatFilter
+  _sum: IntFilter
+  _min: IntFilter
+  _max: IntFilter
+}
+
+input IntNullableWithAggregatesFilter {
+  equals: Int
+  not: Int
+  in: [Int!]
+  notIn: [Int!]
+  lt: Int
+  lte: Int
+  gt: Int
+  gte: Int
+  _count: IntFilter
+  _avg: FloatFilter
+  _sum: IntFilter
+  _min: IntFilter
+  _max: IntFilter
+}
+
+input FloatWithAggregatesFilter {
+  equals: Float
+  not: Float
+  in: [Float!]
+  notIn: [Float!]
+  lt: Float
+  lte: Float
+  gt: Float
+  gte: Float
+  _count: IntFilter
+  _avg: FloatFilter
+  _sum: FloatFilter
+  _min: FloatFilter
+  _max: FloatFilter
+}
+
+input FloatNullableWithAggregatesFilter {
+  equals: Float
+  not: Float
+  in: [Float!]
+  notIn: [Float!]
+  lt: Float
+  lte: Float
+  gt: Float
+  gte: Float
+  _count: IntFilter
+  _avg: FloatFilter
+  _sum: FloatFilter
+  _min: FloatFilter
+  _max: FloatFilter
+}
+
+input BooleanWithAggregatesFilter {
+  equals: Boolean
+  not: Boolean
+  _count: IntFilter
+  _min: BooleanFilter
+  _max: BooleanFilter
+}
+
+input BooleanNullableWithAggregatesFilter {
+  equals: Boolean
+  not: Boolean
+  _count: IntFilter
+  _min: BooleanFilter
+  _max: BooleanFilter
+}
+
+input DateTimeWithAggregatesFilter {
+  equals: DateTime
+  not: DateTime
+  in: [DateTime!]
+  notIn: [DateTime!]
+  lt: DateTime
+  lte: DateTime
+  gt: DateTime
+  gte: DateTime
+  _count: IntFilter
+  _min: DateTimeFilter
+  _max: DateTimeFilter
+}
+
+input DateTimeNullableWithAggregatesFilter {
+  equals: DateTime
+  not: DateTime
+  in: [DateTime!]
+  notIn: [DateTime!]
+  lt: DateTime
+  lte: DateTime
+  gt: DateTime
+  gte: DateTime
+  _count: IntFilter
+  _min: DateTimeFilter
+  _max: DateTimeFilter
+}
+
+input BigIntWithAggregatesFilter {
+  equals: BigInt
+  not: BigInt
+  in: [BigInt!]
+  notIn: [BigInt!]
+  lt: BigInt
+  lte: BigInt
+  gt: BigInt
+  gte: BigInt
+  _count: IntFilter
+  _avg: FloatFilter
+  _sum: BigIntFilter
+  _min: BigIntFilter
+  _max: BigIntFilter
+}
+
+input BigIntNullableWithAggregatesFilter {
+  equals: BigInt
+  not: BigInt
+  in: [BigInt!]
+  notIn: [BigInt!]
+  lt: BigInt
+  lte: BigInt
+  gt: BigInt
+  gte: BigInt
+  _count: IntFilter
+  _avg: FloatFilter
+  _sum: BigIntFilter
+  _min: BigIntFilter
+  _max: BigIntFilter
+}
+
+input BytesWithAggregatesFilter {
+  equals: Bytes
+  not: Bytes
+  in: [Bytes!]
+  notIn: [Bytes!]
+  _count: IntFilter
+  _min: BytesFilter
+  _max: BytesFilter
+}
+
+input BytesNullableWithAggregatesFilter {
+  equals: Bytes
+  not: Bytes
+  in: [Bytes!]
+  notIn: [Bytes!]
+  _count: IntFilter
+  _min: BytesFilter
+  _max: BytesFilter
+}`;
+}
+function sdlRelationFilters() {
+    return `input RelationFilter {
+  is: JSON
+  isNot: JSON
+}
+
+input ListRelationFilter {
+  every: JSON
+  some: JSON
+  none: JSON
+}
+
+input <Model>OrderByRelationAggregateInput {
+  _count: SortOrder
+}`;
+}
+// ===== Per-model generators =====
+function sdlModelScalarFieldEnum(model) {
+    const scalars = model.fields.filter(f => !f.isRelation && !f.isIgnored);
+    return `enum ${model.name}ScalarFieldEnum {\n${scalars.map(f => `  ${f.name}`).join('\n')}\n}`;
+}
+function sdlWhereInput(model, allModels, enums) {
+    const fields = [];
+    fields.push('  AND: [JSON]');
+    fields.push('  OR: [JSON]');
+    fields.push('  NOT: [JSON]');
+    fields.push('  id: IDFilter');
+    for (const field of model.fields) {
+        if (field.isId)
+            continue;
+        if (field.isIgnored)
+            continue;
+        // Skip cross-collection relation fields
+        const isCrossCollectionRelation = field.isRelation && !allModels.find(m => m.name === field.type && m.isEmbedded);
+        if (isCrossCollectionRelation)
+            continue;
+        // Embedded model fields
+        const embeddedModel = allModels.find(m => m.name === field.type && m.isEmbedded);
+        if (embeddedModel) {
+            if (field.isArray) {
+                fields.push(`  ${field.name}: JSON`);
+            }
+            else {
+                fields.push(`  ${field.name}: ${embeddedModel.name}WhereInput`);
+            }
+            continue;
+        }
+        // Array scalar fields
+        if (field.isArray && !field.isRelation) {
+            const filterType = getArrayFilterName(field.type);
+            fields.push(`  ${field.name}: ${filterType}`);
+            continue;
+        }
+        // Regular scalar fields
+        const filterType = getFilterName(field.type, field.isRequired, enums);
+        fields.push(`  ${field.name}: ${filterType}`);
+    }
+    // Relation filters
+    for (const rel of model.relations) {
+        const targetModel = allModels.find(m => m.name === rel.target);
+        if (targetModel && !targetModel.isEmbedded) {
+            if (rel.type === 'oneToMany' || rel.type === 'manyToMany') {
+                fields.push(`  ${rel.field}: ListRelationFilter`);
+            }
+            else {
+                fields.push(`  ${rel.field}: RelationFilter`);
+            }
+        }
+    }
+    // Fulltext search
+    if (model.fulltextFields && model.fulltextFields.length > 0) {
+        fields.push('  search: String');
+    }
+    return `input ${model.name}WhereInput {\n${fields.join('\n')}\n}`;
+}
+function sdlOrderByWithRelationInput(model, allModels) {
+    const fields = [];
+    // Sortable scalar fields (no Json, no Bytes — they can't be sorted by)
+    const sortableFields = model.fields.filter(f => !f.isRelation && !f.isIgnored && f.type !== 'Json' && f.type !== 'Bytes' && f.type !== 'BigInt');
+    for (const f of sortableFields) {
+        fields.push(`  ${f.name}: SortOrder`);
+    }
+    // Relation order by
+    for (const rel of model.relations) {
+        const targetModel = allModels.find(m => m.name === rel.target);
+        if (targetModel && !targetModel.isEmbedded) {
+            fields.push(`  ${rel.field}: ${rel.target}OrderByRelationAggregateInput`);
+        }
+    }
+    return `input ${model.name}OrderByWithRelationInput {\n${fields.join('\n')}\n}`;
+}
+function sdlWhereUniqueInput(model) {
+    const uniqueFields = model.fields.filter(f => !f.isIgnored && (f.isId || f.isUnique));
+    const fields = uniqueFields.map(f => `  ${f.name}: String`);
+    return `input ${model.name}WhereUniqueInput {\n${fields.join('\n')}\n}`;
+}
+function sdlOrderByWithAggregationInput(model) {
+    const fields = [];
+    const sortableFields = model.fields.filter(f => !f.isRelation && !f.isIgnored && f.type !== 'Json' && f.type !== 'Bytes');
+    for (const f of sortableFields) {
+        fields.push(`  ${f.name}: SortOrder`);
+    }
+    fields.push(`  _count: ${model.name}CountOrderByAggregateInput`);
+    fields.push(`  _max: ${model.name}MaxOrderByAggregateInput`);
+    fields.push(`  _min: ${model.name}MinOrderByAggregateInput`);
+    return `input ${model.name}OrderByWithAggregationInput {\n${fields.join('\n')}\n}`;
+}
+function sdlScalarWhereWithAggregatesInput(model, enums) {
+    const fields = [];
+    fields.push('  AND: [JSON]');
+    fields.push('  OR: [JSON]');
+    fields.push('  NOT: [JSON]');
+    for (const field of model.fields) {
+        if (field.isId)
+            continue;
+        if (field.isIgnored)
+            continue;
+        if (field.isRelation)
+            continue;
+        const embeddedModel = undefined; // embedded won't reach here
+        if (embeddedModel)
+            continue;
+        if (field.isArray) {
+            fields.push(`  ${field.name}: JSON`);
+            continue;
+        }
+        const filterType = getWithAggregatesFilterName(field.type, field.isRequired, enums);
+        fields.push(`  ${field.name}: ${filterType}`);
+    }
+    return `input ${model.name}ScalarWhereWithAggregatesInput {\n${fields.join('\n')}\n}`;
+}
+function sdlAggregateOrderByInputs(model) {
+    const sortableFields = model.fields.filter(f => !f.isRelation && !f.isIgnored && f.type !== 'Json' && f.type !== 'Bytes');
+    const countFields = sortableFields.map(f => `  ${f.name}: SortOrder`);
+    const maxFields = sortableFields.map(f => `  ${f.name}: SortOrder`);
+    const minFields = sortableFields.map(f => `  ${f.name}: SortOrder`);
+    return `input ${model.name}CountOrderByAggregateInput {\n${countFields.join('\n')}\n}
+
+input ${model.name}MaxOrderByAggregateInput {\n${maxFields.join('\n')}\n}
+
+input ${model.name}MinOrderByAggregateInput {\n${minFields.join('\n')}\n}
+
+input ${model.name}OrderByRelationAggregateInput {
+  _count: SortOrder
+}`;
+}
+// ===== Enum filters =====
+function sdlEnumFilter(enumName) {
+    return `input Enum${enumName}Filter {
+  equals: ${enumName}
+  not: ${enumName}
+  in: [${enumName}!]
+  notIn: [${enumName}!]
+}
+
+input Enum${enumName}NullableFilter {
+  equals: ${enumName}
+  not: ${enumName}
+  in: [${enumName}!]
+  notIn: [${enumName}!]
+}
+
+input Enum${enumName}WithAggregatesFilter {
+  equals: ${enumName}
+  not: ${enumName}
+  in: [${enumName}!]
+  notIn: [${enumName}!]
+  _count: IntFilter
+  _min: Enum${enumName}Filter
+  _max: Enum${enumName}Filter
+}
+
+input Enum${enumName}NullableWithAggregatesFilter {
+  equals: ${enumName}
+  not: ${enumName}
+  in: [${enumName}!]
+  notIn: [${enumName}!]
+  _count: IntFilter
+  _min: Enum${enumName}Filter
+  _max: Enum${enumName}Filter
+}`;
+}
+// ===== CreateInput / UpdateInput =====
+function sdlFieldType(fieldType, isArray, isRequired) {
+    let t = fieldType;
+    if (isArray) {
+        t = `[${t}!]`;
+    }
+    return isRequired ? `${t}!` : t;
+}
+function sdlCreateInput(model) {
+    // Non-relation, non-id, non-ignored fields
+    const required = model.fields.filter(f => !f.isRelation && !f.isIgnored && !f.isId
+        && f.isRequired && f.defaultValue === undefined && !f.defaultGenerator);
+    const optional = model.fields.filter(f => !f.isRelation && !f.isIgnored && !f.isId
+        && (!f.isRequired || f.defaultValue !== undefined || !!f.defaultGenerator));
+    const fields = [
+        ...required.map(f => `  ${f.name}: ${sdlFieldType(f.type, f.isArray, true)}`),
+        ...optional.map(f => `  ${f.name}: ${sdlFieldType(f.type, f.isArray, false)}`),
+    ];
+    return `input ${model.name}CreateInput {\n${fields.join('\n')}\n}`;
+}
+function sdlUpdateInput(model) {
+    const fields = model.fields.filter(f => !f.isRelation && !f.isIgnored && !f.isId).map(f => `  ${f.name}: ${sdlFieldType(f.type, f.isArray, false)}`);
+    return `input ${model.name}UpdateInput {\n${fields.join('\n')}\n}`;
+}
+// ===== Main generator class =====
+export class SDLInputTypesGenerator {
+    generateSDL(models, enums) {
+        const nonEmbedded = models.filter(m => !m.isEmbedded);
+        const parts = [];
+        const nl = '\n\n';
+        parts.push(sdlScalars());
+        parts.push(sdlBatchPayload());
+        parts.push(sdlSortEnums());
+        parts.push(sdlSortOrderInput());
+        // Base filters
+        parts.push(sdlBaseFilters());
+        parts.push(sdlArrayFilters());
+        parts.push(sdlWithAggregatesFilters());
+        parts.push(sdlRelationFilters().replace('<Model>', ''));
+        // Enum definitions + filters (per enum)
+        for (const enm of enums) {
+            parts.push(`enum ${enm.name} {\n${enm.values.map(v => `  ${v}`).join('\n')}\n}`);
+        }
+        for (const enm of enums) {
+            parts.push(sdlEnumFilter(enm.name));
+        }
+        // Per-model types
+        for (const model of nonEmbedded) {
+            parts.push(sdlModelScalarFieldEnum(model));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlWhereInput(model, models, enums));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlOrderByWithRelationInput(model, models));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlWhereUniqueInput(model));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlOrderByWithAggregationInput(model));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlScalarWhereWithAggregatesInput(model, enums));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlAggregateOrderByInputs(model));
+        }
+        // CreateInput / UpdateInput
+        for (const model of nonEmbedded) {
+            parts.push(sdlCreateInput(model));
+        }
+        for (const model of nonEmbedded) {
+            parts.push(sdlUpdateInput(model));
+        }
+        return parts.join(nl);
+    }
+    generateSDLOutput(models, enums) {
+        const sdl = this.generateSDL(models, enums);
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { gql } from 'graphql-tag';
+
+export const inputTypes = gql\`
+${sdl.trim()}
+\`;
+`;
+    }
+}
+//# sourceMappingURL=SDLInputTypesGenerator.js.map