@postxl/generator 0.34.0 → 0.35.0

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

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRoutesIndex = exports.generateRoute = void 0;
 const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const zod_1 = require("../../lib/schema/zod");
 const imports_1 = require("../../lib/imports");
 /**
  * Generates TRPC route for a given model.
@@ -11,22 +9,28 @@ const imports_1 = require("../../lib/imports");
 function generateRoute({ model, meta }) {
     const { idField, defaultField } = model;
     const defaultValueMethod = `
-    getDefault: procedure.query(({ ctx }) => ctx.data.${meta.data.dataServiceName}.${meta.businessLogic.dataRepositoryVariableName}.defaultValue),
+    getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${meta.businessLogic.dataRepositoryVariableName}.defaultValue),
   `;
-    const createMethod = getCreateMethod({ model, meta });
-    const updateMethod = getUpdateMethod({ model, meta });
-    const deleteMethod = getDeleteMethod({ idField, meta });
-    const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImport({
-        items: [model.typeName, meta.types.toBrandedIdTypeFnName],
-        from: meta.types.importPath,
+    const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImports({
+        [meta.types.importPath]: [
+            model.typeName,
+            meta.types.toBrandedIdTypeFnName,
+            meta.types.zodDecoderFnNames.createObject,
+            meta.types.zodDecoderFnNames.updateObject,
+            meta.types.zodDecoderFnNames.upsertObject,
+            meta.types.zodDecoderFnNames.id,
+        ],
+        [meta.businessLogic.importPath]: [
+            meta.businessLogic.update.createActionFunctionNameCreate,
+            meta.businessLogic.update.createActionFunctionNameCreateMany,
+            meta.businessLogic.update.createActionFunctionNameUpdate,
+            meta.businessLogic.update.createActionFunctionNameUpdateMany,
+            meta.businessLogic.update.createActionFunctionNameUpsert,
+            meta.businessLogic.update.createActionFunctionNameUpsertMany,
+            meta.businessLogic.update.createActionFunctionNameDelete,
+            meta.businessLogic.update.createActionFunctionNameDeleteMany,
+        ],
     });
-    for (const relation of (0, fields_1.getRelationFields)(model)) {
-        const depMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
-        imports.addImport({
-            items: [depMeta.types.toBrandedIdTypeFnName],
-            from: depMeta.types.importPath,
-        });
-    }
     return `
 import { z } from 'zod'
 import { procedure, router } from '../trpc'
@@ -39,8 +43,8 @@ export const ${meta.trpc.routerName} = router({
   
   get: procedure
     .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
-    .query(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.get(input)),
-  getMap: procedure.query(({ ctx }) => ctx.data.${meta.data.dataServiceName}.getAll()),
+    .query(({ input, ctx }) => ctx.view.${meta.data.dataServiceName}.get(input)),
+  getMap: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.getAll()),
   getList: procedure
     .input(z.object({
       cursor: CURSOR_DECODER,
@@ -63,51 +67,37 @@ export const ${meta.trpc.routerName} = router({
       .optional(),
     }))
     .query(({ input, ctx }) => {
-      return ctx.data.${meta.data.dataServiceName}.getList(input)
+      return ctx.view.${meta.data.dataServiceName}.getList(input)
     }),
 
-  ${createMethod}
+    create: procedure.input(${meta.types.zodDecoderFnNames.createObject})
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameCreate}(input))),
+    
+    createMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.createObject}))
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameCreateMany}(input))),
+
+    update: procedure.input(${meta.types.zodDecoderFnNames.updateObject})
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpdate}(input))),
+
+    updateMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.updateObject}))
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpdateMany}(input))),
+
+    upsert: procedure.input(${meta.types.zodDecoderFnNames.upsertObject})
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpsert}(input))),
 
-  ${updateMethod}
+    upsertMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.upsertObject}))
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpsertMany}(input))),
+
+    delete: procedure.input(${meta.types.zodDecoderFnNames.id})
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameDelete}(input))),
+    
+    deleteMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.id}))
+      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameDeleteMany}(input))),
 
-  ${deleteMethod}
 })
 `;
 }
 exports.generateRoute = generateRoute;
-function getCreateMethod({ model: { fields }, meta }) {
-    const parameters = fields
-        .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
-        .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`)
-        .join(',');
-    return `
-    create: procedure.input(z.object({ 
-      ${parameters}
-    }))
-      .mutation(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.create(input)),
-`;
-}
-function getUpdateMethod({ model: { fields }, meta }) {
-    const parameters = fields
-        .filter((f) => !f.attributes.isReadonly)
-        .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field, allowAnyOptionalField: field.kind !== 'id' })}`)
-        .join(',');
-    return `update: procedure
-    .input(
-      z.object({ 
-      ${parameters}
-      })
-    )
-    .mutation(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.update(input)),
-  `;
-}
-function getDeleteMethod({ idField, meta }) {
-    return `
-  delete: procedure
-    .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
-    .mutation(({ input, ctx }) => ctx.data.${meta.data.dataServiceName}.delete(input)),
-`;
-}
 /**
  * Generates the index file for all the routes.
  */

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

@@ -12,6 +12,10 @@ const string_1 = require("../../lib/utils/string");
  * Creates a seed file for a given model.
  */
 function generateSeedModel({ model, itemCount, meta, }) {
+    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 imports = imports_1.ImportsGenerator.from(meta.seed.filePath).addImport({
         items: [model.typeName, meta.types.toBrandedIdTypeFnName],
         from: meta.types.importPath,
@@ -245,7 +249,7 @@ function generateEnumFieldExample({ field, mode, index, }) {
  * Creates the seed file that exposes all seed data as single object.
  */
 function generateSeeds({ models, config, }) {
-    const imports = imports_1.ImportsGenerator.from(config.paths.seedPath);
+    const imports = imports_1.ImportsGenerator.from(config.paths.seedLibPath);
     for (const { meta } of models) {
         imports.addImport({
             items: [meta.seed.constantName],
@@ -254,7 +258,7 @@ function generateSeeds({ models, config, }) {
     }
     const seeds = models.map(({ meta }) => `${meta.seed.constantName}`).join(',\n');
     return `
-  import { MockData } from '${config.paths.seedPath}'
+  import { MockData } from '${config.paths.seedLibPath}'
 
   ${imports.generate()}
   

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

@@ -6,10 +6,12 @@ const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
 const zod_1 = require("../../lib/schema/zod");
 const types_1 = require("../../lib/types");
+const jsdoc_1 = require("../../lib/utils/jsdoc");
 /**
  * Generates types for a given model.
  */
 function generateModelTypes({ model, meta }) {
+    var _a, _b;
     const idField = model.idField;
     const imports = imports_1.ImportsGenerator.from(meta.types.filePath);
     let hasLinkedItems = false;
@@ -32,23 +34,23 @@ function generateModelTypes({ model, meta }) {
             from: refEnumMeta.types.filePath,
         });
     }
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    imports.addImport({
+        items: [schemaMeta.types.dto.create, schemaMeta.types.dto.update, schemaMeta.types.dto.upsert],
+        from: schemaMeta.types.dto.path,
+    });
+    const decoderNames = meta.types.zodDecoderFnNames;
     return `
 import { z } from 'zod'
 
 ${imports.generate()}
 
-
-${model.description
-        ? `
-/**
- * ${model.description.split('\n').join('\n * ')} 
- */`
-        : ''}
+${(0, jsdoc_1.toJsDocComment)((_b = (_a = model.description) === null || _a === void 0 ? void 0 : _a.split('\n')) !== null && _b !== void 0 ? _b : [])}
 export type ${meta.types.typeName} = { 
   ${model.fields
         .map((f) => `
-${getFieldComment(f)}
-${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}`)
+      ${getFieldComment(f)}
+      ${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}`)
         .join('\n')}
 }
 
@@ -64,7 +66,7 @@ ${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}`)
 }`}
 
 /**
- * Branded Id type that should be used to identify an instance of this model.
+ * 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}'
@@ -78,12 +80,56 @@ export function ${meta.types.toBrandedIdTypeFnName}(id: ${idField.unbrandedTypeN
 }
 
 /**
- * Zod decoder for validating a Participant object.
+ * Zod decoder for validating a ${meta.userFriendlyName} id.
  */
-export const ${meta.types.zodDecoderFnName} = z.object({
+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(',')}
 })
 
+/**
+ * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
+ */
+export const ${decoderNames.createObject} = z.object({
+  ${model.fields
+        .filter((f) => !f.attributes.isReadonly)
+        .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`)
+        .join(',')}
+})
+
+/**
+ * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
+ */
+export const ${decoderNames.updateObject} = z.object({
+  ${model.fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
+        .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field, allowAnyOptionalField: field.kind !== 'id' })}`)
+        .join(',')}
+})
+
+/**
+ * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
+ */
+export const ${decoderNames.upsertObject} = z.union([${decoderNames.updateObject}, ${decoderNames.createObject}])
+
+/**
+ * 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 an existing ${meta.userFriendlyName} instance.
+ */
+export type ${meta.types.dto.upsert} = ${schemaMeta.types.dto.upsert}<${meta.types.typeName}, ${model.brandedIdType}>
 `;
 }
 exports.generateModelTypes = generateModelTypes;
@@ -99,8 +145,9 @@ function getFieldComment(f) {
     if (examples) {
         comment += ` * ${examples}\n`;
     }
-    if (comment === '')
+    if (comment === '') {
         return '';
+    }
     return `
 /**
 ${comment}*/`;

package/dist/lib/attributes.d.ts

@@ -26,6 +26,11 @@ export type ModelAttributes = {
      * Creates an index on the given fields.
      */
     index?: string[];
+    /**
+     * Schema tag: ´@@Seed()`
+     * Seed to use for random generation.
+     */
+    randomSeed?: number;
 };
 export type FieldAttributes = {
     /**

package/dist/lib/imports.d.ts

@@ -1,4 +1,17 @@
 import * as Types from './schema/types';
+/**
+ * A structured definition of multiple imports: The key of the object is the "from" path,
+ * the value is a list (or single item) of items to import.
+ *
+ * Example:
+ * ```
+ * {
+ *   [meta.data.importPath]: meta.data.repositoryClassName,
+ *   [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
+ * }
+ * ```
+ */
+export type BulkImportDefinition = Record<Types.Path, Types.ImportableTypes[] | Types.ImportableTypes>;
 /**
  * A utility component that lets you generate TypeScript import statements
  * and makes sure every import is only added once.
@@ -24,10 +37,18 @@ export declare class ImportsGenerator {
      *
      * NOTE: You should never add no items from a given path.
      */
-    addImport({ items, from, }: {
-        items: (Types.Fnction | Types.ClassName | Types.TypeName | Types.VariableName)[];
+    addImport({ items, from }: {
+        items: Types.ImportableTypes[];
         from: Types.Path;
     }): ImportsGenerator;
+    /**
+     * Adds a multiple  import statements to the imports list.
+     *
+     * @param entries - A record of items to import indexed by the path.
+     *
+     * NOTE: You should never add no items from a given path.
+     */
+    addImports(entries: BulkImportDefinition): ImportsGenerator;
     /**
      * Returns the TypeScript import statement.
      */

package/dist/lib/imports.js

@@ -25,7 +25,7 @@ class ImportsGenerator {
      *
      * NOTE: You should never add no items from a given path.
      */
-    addImport({ items, from, }) {
+    addImport({ items, from }) {
         // NOTE: Generator relies that there's at least one import statement from a given path.
         if (items.length === 0) {
             throw new Error(`You cannot add an import statement without any items from ${from}.`);
@@ -37,6 +37,24 @@ class ImportsGenerator {
         items.forEach((item) => this._imports[resolvedPath].add(item));
         return this;
     }
+    /**
+     * Adds a multiple  import statements to the imports list.
+     *
+     * @param entries - A record of items to import indexed by the path.
+     *
+     * NOTE: You should never add no items from a given path.
+     */
+    addImports(entries) {
+        for (const [key, items] of Object.entries(entries)) {
+            if (Array.isArray(items)) {
+                this.addImport({ items, from: key });
+            }
+            else {
+                this.addImport({ items: [items], from: key });
+            }
+        }
+        return this;
+    }
     /**
      * Returns the TypeScript import statement.
      */