@postxl/generator 0.74.2 → 1.0.3

package/dist/generators/models/route.generator.d.ts

@@ -1,9 +0,0 @@
-import { ModelMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates TRPC route for a given model.
- */
-export declare function generateRoute({ model, meta }: {
-    model: Model;
-    meta: ModelMetaData;
-}): string;

package/dist/generators/models/route.generator.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRoute = void 0;
-const imports_1 = require("../../lib/imports");
-const types_1 = require("../../lib/schema/types");
-/**
- * Generates TRPC route for a given model.
- */
-function generateRoute({ model, meta }) {
-    const { idField, defaultField } = model;
-    const { scopeName } = meta.update;
-    const defaultValueMethod = `
-    getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.data.defaultValue),
-  `;
-    const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImports({
-        [meta.types.importPath]: [
-            (0, types_1.toAnnotatedTypeName)(model.typeName),
-            meta.types.toBrandedIdTypeFnName,
-            meta.types.zodDecoderFnNames.id,
-        ],
-        [meta.update.serviceClassLocation.import]: [
-            meta.update.createInputDecoder,
-            meta.update.updateInputDecoder,
-            meta.update.upsertInputDecoder,
-        ],
-        [meta.view.serviceLocation.import]: [meta.view.filterOperatorDecoder, meta.view.cursorDecoder],
-    });
-    return /* ts */ `
-import { z } from 'zod'
-import { authMiddleware, procedure, router } from '../trpc'
-
-${imports.generate()}
-
-export const ${meta.trpc.routerName} = router({
-  ${defaultField ? defaultValueMethod : ''}
-  
-  get: procedure
-    .use(authMiddleware)
-    .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
-    .query(({ input, ctx }) => ctx.view.${meta.data.dataServiceName}.get({ id: input, user: ctx.user})),
-  getMap: procedure
-  .use(authMiddleware)
-  .query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.getAll(ctx.user)),
-  getList: procedure
-    .use(authMiddleware)
-    .input(z.object({
-      cursor: ${meta.view.cursorDecoder}.optional(),
-      sort: z.object({
-        field: z.enum([
-          ${model.fields.map((f) => `'${f.name}'`).join(',\n')}
-        ])
-        .transform((v): keyof ${model.typeName} => v),
-        ascending: z.boolean(),
-      })
-      .optional(),
-      filter: z.object({
-        field: z.enum([
-          ${model.fields.map((f) => `'${f.name}'`).join(',\n')}
-        ])
-        .transform((v): keyof ${model.typeName} => v),
-        operator: ${meta.view.filterOperatorDecoder},
-        value: z.union([z.string(), z.number()]),
-      })
-      .optional(),
-    }))
-    .query(({ input, ctx }) => {
-      return ctx.view.${meta.data.dataServiceName}.getList({...input, user: ctx.user })
-    }),
-
-    create: procedure
-      .use(authMiddleware)
-      .input(${meta.update.createInputDecoder})
-      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "create", payload: input})),
-    
-    update: procedure
-      .use(authMiddleware)
-      .input(${meta.update.updateInputDecoder})
-      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "update", payload: input})),
-
-    upsert: procedure
-      .use(authMiddleware)
-      .input(${meta.update.upsertInputDecoder})
-      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsert", payload: input})),
-
-    delete: procedure
-      .use(authMiddleware)
-      .input(${meta.types.zodDecoderFnNames.id})
-      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "delete", payload: input})),
-})
-`;
-}
-exports.generateRoute = generateRoute;

package/dist/generators/models/seed.generator.d.ts

@@ -1,21 +0,0 @@
-import { ModelMetaData } from '../../lib/meta';
-import { Model, SchemaConfig } from '../../lib/schema/schema';
-/**
- * Creates a seed file for a given model.
- */
-export declare function generateSeedModel({ model, itemCount, meta, models, }: {
-    model: Model;
-    itemCount: number;
-    meta: ModelMetaData;
-    models: Model[];
-}): string;
-/**
- * Creates the seed file that exposes all seed data as single object.
- */
-export declare function generateSeeds({ models, config, }: {
-    models: {
-        model: Model;
-        meta: ModelMetaData;
-    }[];
-    config: SchemaConfig;
-}): string;

package/dist/generators/models/seed.generator.js

@@ -1,285 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSeeds = exports.generateSeedModel = void 0;
-const faker_1 = require("@faker-js/faker");
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const types_1 = require("../../lib/schema/types");
-const serializer_1 = require("../../lib/serializer");
-const types_2 = require("../../lib/types");
-const string_1 = require("../../lib/utils/string");
-/**
- * Creates a seed file for a given model.
- */
-function generateSeedModel({ model, itemCount, meta, models, }) {
-    var _a;
-    // NOTE: We seed `faker` independently for each model.
-    //       This way changes to another model or to the ordering of models in the schema doesn't impact the generated values.
-    faker_1.faker.seed((_a = model.attributes.randomSeed) !== null && _a !== void 0 ? _a : 0);
-    const modelMap = new Map();
-    for (const model of models) {
-        modelMap.set(model.name, model);
-    }
-    const imports = imports_1.ImportsGenerator.from(meta.seed.location.path).addImport({
-        items: [(0, types_1.toAnnotatedTypeName)(model.typeName), meta.types.toBrandedIdTypeFnName],
-        from: meta.types.importPath,
-    });
-    for (const relation of (0, fields_1.getRelationFields)(model)) {
-        const depMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
-        if (relation.isRequired) {
-            imports.addImport({
-                items: [depMeta.types.toBrandedIdTypeFnName],
-                from: depMeta.types.importPath,
-            });
-        }
-    }
-    const mode = getExampleMode({ model, maxItemCount: itemCount });
-    const examples = [];
-    for (let i = 1; i <= mode.itemCount; i++) {
-        examples.push(generateExample({ model, index: i, mode, models: modelMap }));
-    }
-    return `
-    ${imports.generate()}
-
-    export const ${meta.seed.constantName}: ${model.typeName}[] = [
-      ${examples.join(',\n')}
-    ]
-  `;
-}
-exports.generateSeedModel = generateSeedModel;
-/**
- * Returns the mode of examples and the number of examples per field for a given model.
- */
-function getExampleMode({ model, maxItemCount }) {
-    let numberOfExamplesPerField = undefined;
-    let sameNumberOfExamplesPerField = true;
-    let numberOfAllPossiblePermutations = 0;
-    for (const field of model.fields) {
-        if ((field.kind === 'scalar' || field.kind === 'relation' || field.kind == 'id') &&
-            field.attributes.examples &&
-            field.attributes.examples.length > 0) {
-            if (numberOfExamplesPerField === undefined) {
-                numberOfExamplesPerField = field.attributes.examples.length;
-                numberOfAllPossiblePermutations = field.attributes.examples.length;
-            }
-            else if (numberOfExamplesPerField !== field.attributes.examples.length) {
-                sameNumberOfExamplesPerField = false;
-            }
-            numberOfAllPossiblePermutations *= field.attributes.examples.length;
-        }
-    }
-    if (numberOfExamplesPerField === undefined) {
-        return { kind: 'Random', itemCount: maxItemCount };
-    }
-    if (sameNumberOfExamplesPerField) {
-        return { kind: 'Tuples', itemCount: numberOfExamplesPerField };
-    }
-    return { kind: 'Permutations', itemCount: Math.min(numberOfAllPossiblePermutations, maxItemCount) };
-}
-function generateExample({ model, index, mode, models, }) {
-    const data = new serializer_1.Serializer();
-    data.append('{');
-    for (const field of model.fields.values()) {
-        data.append(`${field.name}: ${generateFieldData({ field, model, index, mode, models })},`);
-    }
-    data.append('}');
-    return data.print();
-}
-function generateFieldData({ field, model, index, mode, models, }) {
-    switch (field.kind) {
-        case 'id':
-            return generateIdFieldExample({ field, model, index, mode });
-        case 'scalar':
-            return generateScalarFieldExample({ field, model, index, mode });
-        case 'relation':
-            return generateRelationFieldExample({ field, model, index, mode, models });
-        case 'enum':
-            return generateEnumFieldExample({ field, mode, index });
-        default:
-            throw new types_2.ExhaustiveSwitchCheck(field);
-    }
-}
-function generateIdFieldExample({ field, model, index, mode, }) {
-    const idModelMeta = (0, meta_1.getModelMetadata)({ model: field.model });
-    const { hasExample, example } = generateFieldExample({ field, model, index, mode });
-    if (field.unbrandedTypeName === 'string') {
-        if (hasExample && typeof example === 'string' && index <= mode.itemCount) {
-            return `${idModelMeta.types.toBrandedIdTypeFnName}('${quoteSingleQuote(example)}')`;
-        }
-        return `${idModelMeta.types.toBrandedIdTypeFnName}('${index}')`;
-    }
-    else if (field.unbrandedTypeName === 'number') {
-        if (hasExample && typeof example === 'number') {
-            return `${idModelMeta.types.toBrandedIdTypeFnName}(${example})`;
-        }
-        return `${idModelMeta.types.toBrandedIdTypeFnName}(${index})`;
-    }
-    else {
-        throw new Error(`Unsupported id type for ${model.name}.${field.name}: ${field.unbrandedTypeName}`);
-    }
-}
-function quoteSingleQuote(str) {
-    return str.replace(/'/g, "\\'");
-}
-function generateScalarFieldExample({ field, model, index, mode, }) {
-    var _a;
-    const { hasExample, example } = generateFieldExample({ field, model, index, mode });
-    switch (field.tsTypeName) {
-        case 'string': {
-            if (hasExample && typeof example === 'string') {
-                return `'${quoteSingleQuote(example)}'`;
-            }
-            const result = generateMockString({ field, model, index });
-            if (result === null) {
-                return 'null';
-            }
-            if (result === undefined) {
-                return 'undefined';
-            }
-            return `'${result.replace(/'/g, "\\'")}'`;
-        }
-        case 'number': {
-            if (hasExample) {
-                return `${example}`;
-            }
-            switch (field.schemaType) {
-                case 'BigInt':
-                case 'Int':
-                    return generateMockInteger();
-                default:
-                    return generateMockNumber();
-            }
-        }
-        case 'boolean': {
-            if (hasExample) {
-                return `${example}`;
-            }
-            //in case the field is configured with `IsDefaultField` attribute, the first item should be true, all other false
-            if (((_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name) === field.name) {
-                return index === 0 ? 'true' : 'false';
-            }
-            return generateMockBoolean();
-        }
-        case 'Date': {
-            if (hasExample) {
-                // TODO: Maybe we should parse the date example to correct format?
-                return `${example}`;
-            }
-            return generateMockDate();
-        }
-        default: {
-            console.warn(`Unknown scalar type: ${field.tsTypeName}`);
-            return '';
-        }
-    }
-}
-function generateFieldExample({ field, index, mode, }) {
-    if (mode.kind === 'Random') {
-        return { hasExample: false };
-    }
-    if (!field.attributes.examples || field.attributes.examples.length === 0) {
-        return { hasExample: false };
-    }
-    switch (mode.kind) {
-        case 'Permutations': {
-            const example = faker_1.faker.helpers.arrayElement(field.attributes.examples);
-            return { hasExample: true, example };
-        }
-        case 'Tuples': {
-            const example = field.attributes.examples[(index - 1) % field.attributes.examples.length];
-            return { hasExample: true, example };
-        }
-        default: {
-            throw new types_2.ExhaustiveSwitchCheck(mode);
-        }
-    }
-}
-function generateMockString({ field, model, index }) {
-    if (field.name === 'name') {
-        return `${(0, string_1.toPascalCase)(model.name)} ${index}`;
-    }
-    if (field.name === 'email') {
-        return faker_1.faker.internet.email();
-    }
-    return faker_1.faker.lorem.words(3);
-}
-function generateMockInteger() {
-    return faker_1.faker.datatype.number({ precision: 1, min: 1, max: 1000 }).toString();
-}
-function generateMockNumber() {
-    return faker_1.faker.datatype.float({ precision: 0.1, min: 0, max: 1 }).toString();
-}
-function generateMockBoolean() {
-    return faker_1.faker.datatype.boolean().toString();
-}
-function generateMockDate() {
-    const d = faker_1.faker.date.past(3, '2023-04-01T00:00:00.000Z');
-    //set time to midnight UTC
-    d.setUTCHours(0, 0, 0, 0);
-    return `new Date('${d.toISOString()}')`;
-}
-function generateRelationFieldExample({ field, index, model, mode, models, }) {
-    if (!field.isRequired) {
-        return 'null';
-    }
-    const refModel = models.get(field.relationToModel.name);
-    if (!refModel) {
-        throw new Error(`Could not find model ${field.relationToModel.name}`);
-    }
-    const refModelMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-    const refModelExampleMode = getExampleMode({ model: refModel, maxItemCount: mode.itemCount });
-    const referenceId = faker_1.faker.datatype.number({ min: 1, max: refModelExampleMode.itemCount });
-    const brandingFn = refModelMeta.types.toBrandedIdTypeFnName;
-    const { hasExample, example } = generateFieldExample({
-        field: refModel.idField,
-        model: refModel,
-        index,
-        mode: refModelExampleMode,
-    });
-    if (field.unbrandedTypeName === 'string') {
-        if (hasExample && typeof example === 'string') {
-            return `${brandingFn}('${quoteSingleQuote(example)}')`;
-        }
-        return `${brandingFn}('${referenceId}')`;
-    }
-    if (field.unbrandedTypeName === 'number') {
-        if (hasExample && typeof example === 'number') {
-            return `${brandingFn}(${example})`;
-        }
-        return `${brandingFn}(${referenceId})`;
-    }
-    throw new Error(`Unsupported relation id type for ${model.name}.${field.name}: ${field.unbrandedTypeName}`);
-}
-function generateEnumFieldExample({ field, mode, index, }) {
-    if (mode.kind === 'Tuples') {
-        if (field.attributes.examples) {
-            const example = field.attributes.examples[(index - 1) % field.attributes.examples.length];
-            return `'${example}'`;
-        }
-    }
-    return `'${faker_1.faker.helpers.arrayElement(field.enumerator.values)}'`;
-}
-/**
- * Creates the seed file that exposes all seed data as single object.
- */
-function generateSeeds({ models, config, }) {
-    const imports = imports_1.ImportsGenerator.from(config.paths.seedLibPath);
-    for (const { meta } of models) {
-        imports.addImport({
-            items: [meta.seed.constantName],
-            from: meta.seed.location.path,
-        });
-    }
-    const seeds = models.map(({ meta }) => `${meta.seed.constantName}`).join(',\n');
-    return `
-  import { MockData } from '${config.paths.seedLibPath}'
-
-  ${imports.generate()}
-  
-  export const seed: MockData = {
-    ${seeds}
-  }
-  `;
-}
-exports.generateSeeds = generateSeeds;

package/dist/generators/models/stub.generator.d.ts

@@ -1,9 +0,0 @@
-import { ModelMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates a stub definition file for a given model.
- */
-export declare function generateStub({ model, meta }: {
-    model: Model;
-    meta: ModelMetaData;
-}): string;

package/dist/generators/models/stub.generator.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStub = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const types_1 = require("../../lib/types");
-/**
- * Generates a stub definition file for a given model.
- */
-function generateStub({ model, meta }) {
-    const { fields, idField } = model;
-    const imports = imports_1.ImportsGenerator.from(meta.data.stubLocation.path)
-        .addImport({
-        items: [meta.types.toBrandedIdTypeFnName],
-        from: meta.types.importPath,
-    })
-        .addTypeImport({
-        items: [model.typeName],
-        from: meta.types.importPath,
-    });
-    const assignments = getAssignmentStatementModel({
-        fields,
-        nameField: model.nameField,
-        modelName: model.name,
-        imports,
-    });
-    return /* ts */ `
-${imports.generate()}
-
-/**
- * Utility object containing default values for all fields in a model.
- */
-export const ${meta.data.defaultStubConstantName}: ${model.typeName} = {
-	${assignments}
-}
-
-/**
- * Utility function that creates a new ${meta.userFriendlyName} object from a partial object of values.
- */
-export const ${meta.data.stubGenerationFnName} = (
-	item: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName}}>
-): ${model.typeName} => ({
-  ...${meta.data.defaultStubConstantName},
-  ...item,
-  ${idField.name}: item.${idField.name} ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : ${meta.data.defaultStubConstantName}.id,
-})
-`;
-}
-exports.generateStub = generateStub;
-/**
- * Return an assignment statement for a model where each field is assigned null or its type's default value.
- */
-function getAssignmentStatementModel({ fields, nameField, modelName, imports, }) {
-    return fields
-        .map((f) => {
-        if (!f.isRequired) {
-            return `${f.name}: null`;
-        }
-        switch (f.kind) {
-            case 'scalar': {
-                if ((nameField === null || nameField === void 0 ? void 0 : nameField.name) === f.name) {
-                    return `${f.name}: '${modelName}'`;
-                }
-                return `${f.name}: ${(0, fields_1.getDefaultValueForType)(f.tsTypeName)}`;
-            }
-            case 'id': {
-                const idRefMeta = (0, meta_1.getModelMetadata)({ model: f.model });
-                imports.addImport({
-                    items: [idRefMeta.types.toBrandedIdTypeFnName],
-                    from: idRefMeta.types.importPath,
-                });
-                return `${f.name}: ${idRefMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
-            }
-            case 'relation': {
-                const refModelMeta = (0, meta_1.getModelMetadata)({ model: f.relationToModel });
-                imports.addImport({
-                    items: [refModelMeta.types.toBrandedIdTypeFnName],
-                    from: refModelMeta.types.importPath,
-                });
-                return `${f.name}: ${refModelMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
-            }
-            case 'enum': {
-                return `${f.name}: "${f.enumerator.values[0]}"`;
-            }
-            default: {
-                throw new types_1.ExhaustiveSwitchCheck(f);
-            }
-        }
-    })
-        .join(',\n');
-}

package/dist/generators/models/types.generator.d.ts

@@ -1,9 +0,0 @@
-import { ModelMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates types for a given model.
- */
-export declare function generateModelTypes({ model, meta }: {
-    model: Model;
-    meta: ModelMetaData;
-}): string;

package/dist/generators/models/types.generator.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateModelTypes = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const typescript_1 = require("../../lib/typescript");
-const jsdoc_1 = require("../../lib/utils/jsdoc");
-const zod_1 = require("../../lib/zod");
-/**
- * Generates types for a given model.
- */
-function generateModelTypes({ model, meta }) {
-    var _a;
-    const idField = model.idField;
-    const imports = imports_1.ImportsGenerator.from(meta.types.filePath);
-    for (const f of (0, fields_1.getEnumFields)(model)) {
-        const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
-        imports.addTypeImport({
-            items: [f.enumerator.tsTypeName],
-            from: refEnumMeta.types.filePath,
-        });
-    }
-    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    imports.addTypeImport({
-        items: [schemaMeta.types.dto.create, schemaMeta.types.dto.update, schemaMeta.types.dto.upsert],
-        from: schemaMeta.types.dto.path,
-    });
-    const decoderNames = meta.types.zodDecoderFnNames;
-    for (const relation of (0, fields_1.getRelationFields)(model)) {
-        if (relation.relationToModel.typeName === model.typeName) {
-            // NOTE: All type definitions are already present in this file for this model.
-            continue;
-        }
-        const refMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
-        imports.addImport({ from: refMeta.types.filePath, items: [refMeta.types.toBrandedIdTypeFnName] });
-        imports.addTypeImport({ from: refMeta.types.filePath, items: [relation.relationToModel.brandedIdType] });
-    }
-    return /* ts */ `
-import { z } from 'zod'
-
-${imports.generate()}
-
-${(0, jsdoc_1.toJsDocComment)((_a = model.description) === null || _a === void 0 ? void 0 : _a.split('\n'))}
-export type ${meta.types.typeName} = { 
-  ${model.fields
-        .map((f) => {
-        return `
-        ${(0, jsdoc_1.getFieldComment)(f)}
-        ${f.name}: ${(0, typescript_1.getFieldType)(f)}${f.isRequired ? '' : ' | null'}
-      `;
-    })
-        .join('\n')}
-}
-
-/**
- * Branded Id type that should be used to identify an instance of a ${meta.userFriendlyName}.
- */
-export type ${model.brandedIdType} = ${idField.unbrandedTypeName} & {
-  readonly ___type: '${model.typeName}'
-}
-
-/**
- * Converts a given scalar to a branded id type. 
- */
-export function ${meta.types.toBrandedIdTypeFnName}(id: ${idField.unbrandedTypeName}): ${model.brandedIdType} {
-  return id as ${model.brandedIdType}
-}
-
-/**
- * Zod decoder for validating a ${meta.userFriendlyName} id.
- */
-export const ${decoderNames.id} = z.${(0, zod_1.getZodDecoderDefinition)({ field: idField })}
-
-/**
- * Zod decoder for validating a ${meta.userFriendlyName} from the database.
- */
-export const ${decoderNames.fromDatabase} = z.object({
-  ${model.fields.map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`).join(',')}
-})
-
-/**
- * Data transfer object for creating a new ${meta.userFriendlyName} instance.
- */
-export type ${meta.types.dto.create} = ${schemaMeta.types.dto.create}<${meta.types.typeName}, ${model.brandedIdType}>
-
-/**
- * Data transfer object for updating an existing ${meta.userFriendlyName} instance.
- */
-export type ${meta.types.dto.update} = ${schemaMeta.types.dto.update}<${meta.types.typeName}, ${model.brandedIdType}>
-
-/**
- * Data transfer object for upserting a new or existing ${meta.userFriendlyName} instance.
- */
-export type ${meta.types.dto.upsert} = ${schemaMeta.types.dto.upsert}<${meta.types.typeName}, ${model.brandedIdType}>
-
-/**
- * Data transfer object for cloning a new ${meta.userFriendlyName} instance.
- */
-export type ${meta.types.dto.clone} = { 
-  ${model.fields
-        .map((f) => {
-        const type = (0, typescript_1.getFieldType)(f);
-        // NOTE: ID field is always required to resolve the source.
-        if (f.kind === 'id') {
-            return `${f.name}: ${type}`;
-        }
-        if (f.isUnique) {
-            // NOTE: `unique` fields require a new value.
-            if (f.isRequired) {
-                return `${f.name}: ${type}`;
-            }
-            return `${f.name}: ${type} | null`;
-        }
-        // NOTE: Non-unique fields can be copied from the source.
-        if (f.isRequired) {
-            return `${f.name}?: ${type}`;
-        }
-        return `${f.name}?: ${type} | null`;
-    })
-        .join(', ')} 
-}
-`;
-}
-exports.generateModelTypes = generateModelTypes;

package/dist/generators/models/update/service.generator.d.ts

@@ -1,10 +0,0 @@
-import { ModelMetaData } from '../../../lib/meta';
-import { Model } from '../../../lib/schema/schema';
-/**
- * Generates update business logic for a given model.
- * The update logic handles all Create/Update/Delete/Upsert operations. See template's readme for more info.
- */
-export declare function generateModelBusinessLogicUpdate({ model, meta }: {
-    model: Model;
-    meta: ModelMetaData;
-}): string;