@postxl/generator 0.13.0 → 0.14.0

package/dist/generator.js

@@ -61,6 +61,8 @@ const meta_1 = require("./lib/meta");
 const types_1 = require("./lib/schema/types");
 const client_path_1 = require("./prisma/client-path");
 const parse_1 = require("./prisma/parse");
+const seed_template_decoder_generator_1 = require("./generators/indices/seed-template-decoder.generator");
+const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
 const CONFIG_SCHEMA = zod_1.z
     .object({
     project: zod_1.z.string(),
@@ -188,6 +190,8 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         }
         if (!config.disableGenerators.seed) {
             generated.write(`/${meta.seed.indexFilePath}.ts`, (0, seed_generator_1.generateSeedIndex)({ models, meta }));
+            generated.write(`/${meta.seed.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
+            generated.write(`/${meta.seed.templateDecoderFilePath}.ts`, (0, seed_template_decoder_generator_1.generateSeedTemplateDecoder)({ models, meta }));
         }
         if (!config.disableGenerators.trpc) {
             generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ models, meta }));

package/dist/generators/indices/datamockmodule.generator.js

@@ -51,7 +51,7 @@ function generateDataMockModule({ models, meta }) {
         imports.addImport({ items: [meta.data.mockRepositoryClassName], from: meta.data.mockRepoFilePath });
     }
     const providers = mm
-        .map(({ meta, model }) => `{ 
+        .map(({ meta }) => `{ 
           provide: ${meta.data.repositoryClassName},
           useFactory: async () => {
             const repository = new ${meta.data.mockRepositoryClassName}()

package/dist/generators/indices/seed-template-decoder.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Creates a decoder for the Seed Excel template
+ */
+export declare function generateSeedTemplateDecoder({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/seed-template-decoder.generator.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedTemplateDecoder = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/types");
+/**
+ * Creates a decoder for the Seed Excel template
+ */
+function generateSeedTemplateDecoder({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.seed.templateDecoderFilePath);
+    const decoders = [];
+    const tableDecoders = [];
+    const renameTransforms = [];
+    for (const model of [...models].sort((a, b) => a.name.localeCompare(b.name))) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        decoders.push(generateTableDecoder({ model, meta: modelMeta, imports }));
+        tableDecoders.push(`${modelMeta.seed.excel.tableName}: z.array(${modelMeta.seed.decoder.schemaName})`);
+        renameTransforms.push(`${modelMeta.seed.decoder.dataName}: item['${modelMeta.seed.excel.tableName}']`);
+    }
+    return `
+  import * as z from 'zod'
+  import { excelStringDecoder, excelStringNullableDecoder, excelBooleanDecoder, excelDateNullableDecoder, excelDateDecoder }  from '@pxl/common'
+  
+  ${imports.generate()}
+  
+  ${decoders.join('\n')}
+
+  export const seedTemplateDecoder = z
+    .object({${tableDecoders.join(',\n')}})
+    .transform((item) => ({${renameTransforms.join(',\n')}}))
+  `;
+}
+exports.generateSeedTemplateDecoder = generateSeedTemplateDecoder;
+function generateTableDecoder({ model, meta, imports, }) {
+    const fieldDecoders = [];
+    const renameTransforms = [];
+    for (const field of model.fields) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
+        renameTransforms.push(`${field.name}: item['${fieldMeta.excelColumnName}']`);
+        switch (field.kind) {
+            case 'id': {
+                imports.addImport({
+                    items: [meta.types.toBrandedIdTypeFnName],
+                    from: meta.types.filePath,
+                });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    typeName: field.unbrandedTypeName,
+                    nullable: false,
+                })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
+                break;
+            }
+            case 'scalar': {
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    typeName: field.typeName,
+                    nullable: !field.isRequired,
+                })}`);
+                break;
+            }
+            case 'relation': {
+                const refModel = field.relationToModel;
+                const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+                imports.addImport({
+                    items: [refMeta.types.toBrandedIdTypeFnName],
+                    from: refMeta.types.filePath,
+                });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    typeName: field.unbrandedTypeName,
+                    nullable: !field.isRequired,
+                })}.transform((id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => ${field.isRequired ? '' : ' id === null ? null : '}${refMeta.types.toBrandedIdTypeFnName}(id))`);
+                break;
+            }
+            case 'enum': {
+                const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: field.enumerator });
+                imports.addImport({
+                    items: [field.enumerator.typeName],
+                    from: refEnumMeta.types.filePath,
+                });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([${field.enumerator.values.map((v) => `'${v}'`).join(', ')}])${field.isRequired ? '' : '.nullable()'}`);
+                break;
+            }
+            default: {
+                throw new types_1.ExhaustiveSwitchCheck(field);
+            }
+        }
+    }
+    return `  
+/**
+ * The schema for the ${model.name} table
+ */
+const ${meta.seed.decoder.schemaName} = z
+  .object({${fieldDecoders.join(',\n')}})
+  .transform((item) => ({${renameTransforms.join(',\n')}}))
+  
+/**
+ * The type of the ${model.name} table
+ */
+export type ${meta.seed.decoder.decoderTypeName} = z.infer<typeof ${meta.seed.decoder.schemaName}>
+
+export const ${meta.seed.decoder.decoderName} = z.array(${meta.seed.decoder.schemaName})
+`;
+}
+function toExcelDecoder({ typeName, nullable }) {
+    switch (typeName) {
+        case 'string':
+            return nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder';
+        case 'boolean':
+            return 'excelBooleanDecoder';
+        case 'number':
+            return `z.number()${nullable ? '.nullable()' : ''}`;
+        case 'Date':
+            return nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder';
+        default:
+            throw new Error('Unknown type');
+    }
+}

package/dist/generators/indices/seed-template.generator.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Model } from '../../lib/schema/schema';
+/**
+ * Creates an Excel template file that can be used to manage Seed data.
+ * The template file contains a sheet for each model, with the column for each field.
+ */
+export declare function generateSeedExcelTemplate({ models }: {
+    models: Model[];
+}): Promise<Buffer>;

package/dist/generators/indices/seed-template.generator.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedExcelTemplate = void 0;
+const Excel = __importStar(require("exceljs"));
+const meta_1 = require("../../lib/meta");
+/**
+ * Creates an Excel template file that can be used to manage Seed data.
+ * The template file contains a sheet for each model, with the column for each field.
+ */
+function generateSeedExcelTemplate({ models }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const wb = initializeWorkbook();
+        for (const model of [...models].sort((a, b) => a.name.localeCompare(b.name))) {
+            const meta = (0, meta_1.getModelMetadata)({ model });
+            addModel({ model, meta, wb });
+        }
+        const buffer = Buffer.from(yield wb.xlsx.writeBuffer());
+        return buffer;
+    });
+}
+exports.generateSeedExcelTemplate = generateSeedExcelTemplate;
+function initializeWorkbook() {
+    const wb = new Excel.Workbook();
+    wb.creator = 'XLPort';
+    wb.lastModifiedBy = 'XLPort';
+    wb.created = new Date();
+    wb.modified = new Date();
+    return wb;
+}
+function addModel({ model, meta, wb }) {
+    const ws = wb.addWorksheet(model.name);
+    const table = ws.addTable({
+        name: meta.seed.excel.tableName,
+        ref: 'A1',
+        headerRow: true,
+        totalsRow: false,
+        style: {
+            theme: 'TableStyleMedium2',
+            showRowStripes: true,
+        },
+        columns: model.fields.map((field) => ({
+            name: (0, meta_1.getFieldMetadata)({ field }).excelColumnName,
+        })),
+        rows: [],
+    });
+    table.addRow(model.fields.map(() => null));
+    table.commit();
+}

package/dist/generators/models/react.generator/library.generator.js

@@ -56,13 +56,14 @@ function generateModelLibraryComponents({ model, meta }) {
     /**
      * Show a single ${model.name} entry.
      */
-    export const ${components.cardComponentName} = ({ item }: { item: ${model.typeName} }) => {
+    export const ${components.cardComponentName} = React.forwardRef<HTMLLIElement, { item: ${model.typeName} }>(({ item }, forwardedRef) => {
       const [isEditModalOpen, setIsEditModalOpen] = useState(false)
       const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false)
 
       return (
         <>
           <Card
+            ref={forwardedRef}
             title={item.name}
             actions={[
               {
@@ -96,7 +97,9 @@ function generateModelLibraryComponents({ model, meta }) {
           />
         </>
       )
-    }
+    })
+
+    ${components.cardComponentName}.displayName = '${components.cardComponentName}'
   `;
 }
 exports.generateModelLibraryComponents = generateModelLibraryComponents;

package/dist/generators/models/react.generator/modals.generator.js

@@ -391,7 +391,7 @@ function getFormFieldComponents({ model }) {
             case 'scalar': {
                 // Each scalar field has a different generic component based on the provided type.
                 scalar: switch (field.typeName) {
-                    case 'string':
+                    case 'string': {
                         form.append(`
               <div>
                 <Label>${label}</Label>
@@ -399,7 +399,8 @@ function getFormFieldComponents({ model }) {
               </div>
             `);
                         break scalar;
-                    case 'number':
+                    }
+                    case 'number': {
                         let decimals = 0;
                         if (((_a = field.validation) === null || _a === void 0 ? void 0 : _a.type) === 'float') {
                             decimals = 2;
@@ -411,7 +412,8 @@ function getFormFieldComponents({ model }) {
               </div>
             `);
                         break scalar;
-                    case 'boolean':
+                    }
+                    case 'boolean': {
                         form.append(`
               <div>
                 <Label>Is ${label}</Label>
@@ -419,12 +421,15 @@ function getFormFieldComponents({ model }) {
               </div>
             `);
                         break scalar;
-                    case 'Date':
+                    }
+                    case 'Date': {
                         form.append(`{/*  Skipped date field ${field.name}. */}`);
                         break scalar;
-                    default:
+                    }
+                    default: {
                         console.warn(`Unknown scalar type ${field.typeName} for field ${model.name}.${field.name}.`);
                         break scalar;
+                    }
                 }
                 break;
             }

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

@@ -41,14 +41,16 @@ function generateRepository({ model, meta }) {
         };
     };
     const indexes = model.attributes.index ? [getIndexDefinition(model.attributes.index)] : [];
-    const defaultValueInitFn = `
+    const defaultValueInitFn = model.defaultField
+        ? `
 		if (item.${(_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name}) {
 			if (this.defaultValue) {
 				console.warn(\`More than one default ${meta.userFriendlyName} found! \${this.defaultValue.id} and \${item.id}\`)
 			}
 			this.defaultValue = item
 		}
-	`;
+	`
+        : '';
     const defaultValueInitCheckFn = `
 		if (!this.db.isCLI && !this.defaultValue) {
       throw new Error('No default ${meta.userFriendlyName} found!')
@@ -405,17 +407,22 @@ export class ${meta.data.repositoryClassName} implements Repository<
     }
   `)
         .join('\n')}
-  ${maxLengthStringFields.map((f) => {
-        return `
-  /**
-   * Utility function that ensures that the ${f.name} field has a max length of ${f.attributes.maxLength}
-   */      
-  private ${getEnsureMaxLengthFnName(f)}(item: { ${f.name}?: string }) {
-    if (!item.${f.name}) return
-    if (item.${f.name}.length <= ${f.attributes.maxLength}) return
-    item.${f.name} = item.${f.name}.substring(0, ${f.attributes.maxLength - 4}) + \`...\`
-  }`;
-    })}
+
+  ${maxLengthStringFields
+        .map((f) => `
+      /**
+       * Utility function that ensures that the ${f.name} field has a max length of ${f.attributes.maxLength}
+       */      
+      private ${getEnsureMaxLengthFnName(f)}(item: { ${f.name}?: string }) {
+        if (!item.${f.name}) {
+          return
+        }
+        if (item.${f.name}.length <= ${f.attributes.maxLength}) {
+          return
+        }
+        item.${f.name} = item.${f.name}.substring(0, ${f.attributes.maxLength - 4}) + \`...\`
+      }`)
+        .join('\n')}
 
   ${uniqueStringFields
         .map((f) => {

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

@@ -95,39 +95,57 @@ function generateFieldData({ field, model, index, exampleMode, }) {
             throw new types_1.ExhaustiveSwitchCheck(field);
     }
 }
-function generateFieldDataId({ field, model, index }) {
+function generateFieldDataId({ field, index }) {
     const idModelMeta = (0, meta_1.getModelMetadata)({ model: field.model });
     return `${idModelMeta.types.toBrandedIdTypeFnName}(${field.unbrandedTypeName === 'string' ? `'${index}'` : index})`;
 }
-function quoteSingleQuote(str) {
-    return str !== null ? str.replace(/'/g, "\\'") : null;
-}
 function generateFieldDataScalar({ field, model, index, exampleMode, }) {
     const { hasExample, example } = getFieldExample({ field, model, index, exampleMode });
     switch (field.typeName) {
-        case 'string':
-            const result = hasExample ? example : generateFieldDataString({ field, model, index });
-            if (result === null)
+        case 'string': {
+            if (hasExample) {
+                return `${example}`;
+            }
+            const result = generateFieldDataString({ field, model, index });
+            if (result === null) {
                 return 'null';
-            if (result === undefined)
+            }
+            if (result === undefined) {
                 return 'undefined';
-            return `'${quoteSingleQuote(result)}'`;
-        case 'number':
-            return hasExample ? example : generateFieldDataNumber({ field, model, index });
-        case 'boolean':
-            return hasExample ? example : generateFieldDataBoolean({ field, model, index });
-        case 'Date':
-            return hasExample ? example : generateFieldDataDate({ field, model, index });
-        default:
+            }
+            return `'${result.replace(/'/g, "\\'")}'`;
+        }
+        case 'number': {
+            if (hasExample) {
+                return `${example}`;
+            }
+            return generateFieldDataNumber();
+        }
+        case 'boolean': {
+            if (hasExample) {
+                return `${example}`;
+            }
+            return generateFieldDataBoolean();
+        }
+        case 'Date': {
+            if (hasExample) {
+                // TODO: Maybe we should parse the date example to correct format?
+                return `${example}`;
+            }
+            return generateFieldDataDate();
+        }
+        default: {
             console.warn(`Unknown scalar type: ${field.typeName}`);
             return '';
+        }
     }
 }
-function getFieldExample({ field, model, index, exampleMode, }) {
-    if (exampleMode.mode === 'NoExamples')
-        return { hasExample: false, example: undefined };
+function getFieldExample({ field, index, exampleMode, }) {
+    if (exampleMode.mode === 'NoExamples') {
+        return { hasExample: false };
+    }
     if (!field.attributes.examples || field.attributes.examples.length === 0) {
-        return { hasExample: false, example: undefined };
+        return { hasExample: false };
     }
     switch (exampleMode.mode) {
         case 'Permutations': {
@@ -138,30 +156,33 @@ function getFieldExample({ field, model, index, exampleMode, }) {
             const example = field.attributes.examples[(index - 1) % field.attributes.examples.length];
             return { hasExample: true, example };
         }
-        default:
+        default: {
             throw new types_1.ExhaustiveSwitchCheck(exampleMode);
+        }
     }
 }
 function generateFieldDataString({ field, model, index }) {
-    if (field.name === 'name')
+    if (field.name === 'name') {
         return `${(0, string_1.toPascalCase)(model.name)} ${index}`;
-    if (field.name === 'email')
+    }
+    if (field.name === 'email') {
         return faker_1.faker.internet.email();
+    }
     return faker_1.faker.lorem.words(3);
 }
-function generateFieldDataNumber({}) {
+function generateFieldDataNumber() {
     return faker_1.faker.datatype.float({ precision: 0.1, min: 0, max: 1 }).toString();
 }
-function generateFieldDataBoolean({}) {
+function generateFieldDataBoolean() {
     return faker_1.faker.datatype.boolean().toString();
 }
-function generateFieldDataDate({ field, model, index }) {
+function generateFieldDataDate() {
     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 generateFieldDataRelation({ field, model, index, itemCount, }) {
+function generateFieldDataRelation({ field, itemCount, }) {
     const referenceId = faker_1.faker.datatype.number({ min: 1, max: itemCount });
     const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
     const brandingFn = refModelMeta.types.toBrandedIdTypeFnName;

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

@@ -53,18 +53,23 @@ function getAssigmentStatementModel({ fields }) {
             return `${f.name}: null`;
         }
         switch (f.kind) {
-            case 'scalar':
+            case 'scalar': {
                 return `${f.name}: ${(0, fields_1.getDefaultValueForType)(f.typeName)}`;
-            case 'id':
+            }
+            case 'id': {
                 const idRefMeta = (0, meta_1.getModelMetadata)({ model: f.model });
                 return `${f.name}: ${idRefMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
-            case 'relation':
+            }
+            case 'relation': {
                 const refModelMeta = (0, meta_1.getModelMetadata)({ model: f.relationToModel });
                 return `${f.name}: ${refModelMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
-            case 'enum':
+            }
+            case 'enum': {
                 return `${f.name}: "${f.enumerator.values[0]}"`;
-            default:
+            }
+            default: {
                 throw new types_1.ExhaustiveSwitchCheck(f);
+            }
         }
     })
         .join(',\n');

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

@@ -90,8 +90,9 @@ function getFieldComment(f) {
 ${comment}*/`;
 }
 function getFieldExamples(f) {
-    if (!f.attributes.examples)
+    if (!f.attributes.examples) {
         return undefined;
+    }
     return `Examples: ${f.attributes.examples.map((e) => `"${e}"`).join(', ')}`;
 }
 /**

package/dist/lib/attributes.d.ts

@@ -51,7 +51,7 @@ export type FieldAttributes = {
     /**
      * Schema tag: ´@@Examples("Example1", "Example2")`
      */
-    examples?: unknown[];
+    examples?: (string | number | boolean)[];
     /**
      * Schema tag: ´@@DefaultField()`
      * The property of the model that identifies the default row.

package/dist/lib/imports.d.ts

@@ -25,7 +25,7 @@ export declare class ImportsGenerator {
      * NOTE: You should never add no items from a given path.
      */
     addImport({ items, from, }: {
-        items: (Types.Function | Types.ClassName | Types.TypeName | Types.VariableName)[];
+        items: (Types.Fnction | Types.ClassName | Types.TypeName | Types.VariableName)[];
         from: Types.Path;
     }): ImportsGenerator;
     /**

package/dist/lib/meta.d.ts

@@ -39,6 +39,14 @@ export type SchemaMetaData = {
          * Path to the index file for the seed package.
          */
         indexFilePath: Types.Path;
+        /**
+         * Path to seed Excel template file.
+         */
+        templateExcelFilePath: Types.Path;
+        /**
+         * Path to template decoder file.
+         */
+        templateDecoderFilePath: Types.Path;
         /**
          * Path that may be used in the import statement.
          */
@@ -116,7 +124,7 @@ export type ModelMetaData = {
         /**
          * The name of the function that adds missing values to the partially populated model value.
          */
-        stubGenerationFnName: Types.Function;
+        stubGenerationFnName: Types.Fnction;
         /**
          * Name of the file containing the repository definition for this model.
          */
@@ -153,11 +161,11 @@ export type ModelMetaData = {
             /**
              * The name of the function that decodes a source (database) object to a fully typed object, e.g. `toAggregation`.
              */
-            decoderFnName: Types.Function;
+            decoderFnName: Types.Fnction;
             /**
              * The name of the method that should be used to get objects from the database, e.g. `aggregations`.
              */
-            getMethodFnName: Types.Function;
+            getMethodFnName: Types.Fnction;
         };
     };
     seed: {
@@ -173,6 +181,30 @@ export type ModelMetaData = {
          * The file or package name that contains the seed data for this model (e.g. `@d2i/aggregations`).
          */
         importPath: Types.Path;
+        excel: {
+            /**
+             * The name of the Excel table, e.g. `Aggregations`.
+             */
+            tableName: string;
+        };
+        decoder: {
+            /**
+             * The name of the Zod schema, e.g. `aggregationSchema`.
+             */
+            schemaName: Types.VariableName;
+            /**
+             * The name of the decoder, e.g. `aggregationDecoder`.
+             */
+            decoderName: Types.VariableName;
+            /**
+             * The name of the inferred decoder type, e.g. `AggregationType`.
+             */
+            decoderTypeName: Types.TypeName;
+            /**
+             * The name of the resulting field in the seed data
+             */
+            dataName: Types.VariableName;
+        };
     };
     react: {
         /**
@@ -187,11 +219,11 @@ export type ModelMetaData = {
             /**
              * Name of the function that should be used as React hook (e.g. `useAggregationContext`).
              */
-            hookFnName: Types.Function;
+            hookFnName: Types.Fnction;
             /**
              * Name of the function that may be used to get a single instance of this model (e.g. `useAggregation`).
              */
-            instanceGetterHookFnName: Types.Function;
+            instanceGetterHookFnName: Types.Fnction;
             /**
              * Name of the context wrapper.
              */
@@ -253,7 +285,7 @@ export type ModelMetaData = {
             /**
              * The full method name of the React Query method (e.g. `aggregations.getMap`).
              */
-            reactQueryMethod: Types.Function;
+            reactQueryMethod: Types.Fnction;
         };
         create: {
             /**
@@ -263,7 +295,7 @@ export type ModelMetaData = {
             /**
              * The full method name of the React Query method (e.g. `aggregations.create`).
              */
-            reactQueryMethod: Types.Function;
+            reactQueryMethod: Types.Fnction;
         };
         update: {
             /**
@@ -273,7 +305,7 @@ export type ModelMetaData = {
             /**
              * The full method name of the React Query method (e.g. `aggregations.update`).
              */
-            reactQueryMethod: Types.Function;
+            reactQueryMethod: Types.Fnction;
         };
         delete: {
             /**
@@ -283,7 +315,7 @@ export type ModelMetaData = {
             /**
              * The full method name of the React Query method (e.g. `aggregations.delete`).
              */
-            reactQueryMethod: Types.Function;
+            reactQueryMethod: Types.Fnction;
         };
     };
     types: {
@@ -303,11 +335,11 @@ export type ModelMetaData = {
          * Function that may be used to convert a scalar value to a branded ID type,
          * e.g. `toAggregationId`.
          */
-        toBrandedIdTypeFnName: Types.Function;
+        toBrandedIdTypeFnName: Types.Fnction;
         /**
          * The name of the function that decodes a source (database) object to a fully typed object, e.g. `aggregationDecoder`.
          */
-        zodDecoderFnName: Types.Function;
+        zodDecoderFnName: Types.Fnction;
         /**
          * The name of the file containing type definitions (e.g. `aggregation.type`).
          */
@@ -332,11 +364,15 @@ export type FieldMetaData = {
     /**
      * The name of the method that should be used to get all child objects for a given item, e.g. `getItemsForAggregation`.
      */
-    getByForeignKeyMethodFnName: Types.Function;
+    getByForeignKeyMethodFnName: Types.Fnction;
     /**
      * The name of the method that should be used to get all child Ids for a given item, e.g. `getIdsForAggregation`.
      */
-    getByForeignKeyIdsMethodFnName: Types.Function;
+    getByForeignKeyIdsMethodFnName: Types.Fnction;
+    /**
+     * The name of the column in the seed Excel table, e.g. `Aggregation`.
+     */
+    excelColumnName: string;
 };
 /**
  * A collection of hardcoded values shared across multiple generators related to the given field in the model.

package/dist/lib/meta.js

@@ -46,6 +46,8 @@ function getSchemaMetadata({ config }) {
         },
         seed: {
             indexFilePath: Types.toPath(`${config.paths.seedPath}index`),
+            templateExcelFilePath: Types.toPath(`${config.paths.seedPath}template.xlsx`),
+            templateDecoderFilePath: Types.toPath(`${config.paths.seedPath}seed-decoder`),
             importPath: Types.toPath(`@${config.project}/seed`),
             randomSeed: config.randomSeed,
         },
@@ -63,7 +65,7 @@ exports.getSchemaMetadata = getSchemaMetadata;
  */
 function getModelMetadata({ model }) {
     const { name, schemaConfig: config } = model;
-    const { PascalCase, camelCase, pluralized, uncapitalizedPlural } = (0, string_1.conjugateNames)(name);
+    const { PascalCase, camelCase, pluralized, uncapitalizedPlural, capitalizedPlural } = (0, string_1.conjugateNames)(name);
     return {
         userFriendlyName: PascalCase,
         data: {
@@ -89,6 +91,15 @@ function getModelMetadata({ model }) {
             filePath: Types.toPath(`${config.paths.seedPath}${uncapitalizedPlural}`),
             constantName: Types.toVariableName(`${uncapitalizedPlural}`),
             importPath: Types.toPath(`@${config.project}/seed`),
+            excel: {
+                tableName: `${capitalizedPlural}`,
+            },
+            decoder: {
+                schemaName: Types.toVariableName(`${camelCase}Schema`),
+                decoderTypeName: Types.toTypeName(`${PascalCase}DecoderType`),
+                decoderName: Types.toVariableName(`${camelCase}Decoder`),
+                dataName: Types.toVariableName(`${uncapitalizedPlural}`),
+            },
         },
         react: {
             folderName: Types.toFolderName(`${PascalCase}`),
@@ -161,6 +172,7 @@ function getFieldMetadata({ field }) {
         tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
         getByForeignKeyMethodFnName: Types.toFunction(`getItemsFor${PascalCase}`),
         getByForeignKeyIdsMethodFnName: Types.toFunction(`getIdsFor${PascalCase}`),
+        excelColumnName: (0, string_1.toPascalCase)(field.name),
     };
     // switch (field.kind) {
     //   case 'id':

package/dist/lib/schema/types.d.ts

@@ -11,13 +11,13 @@ export declare const toTypeName: (t: string) => TypeName;
 /**
  * The name of a function (e.g. "toAggregation").
  */
-export type Function = string & {
+export type Fnction = string & {
     readonly ___type: 'FunctionName';
 };
 /**
  * Converts a string to a branded function name.
  */
-export declare const toFunction: (t: string) => Function;
+export declare const toFunction: (t: string) => Fnction;
 /**
  * The name of a class, e.g. "AggregationRepository".
  */

package/dist/lib/utils/file.js

@@ -40,6 +40,8 @@ function _resolvePath(path) {
     const chunks = path.split('/');
     const resolved = [];
     while (chunks.length > 0) {
+        // NOTE: We can safely force unwrap here because we check the length of the array.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const chunk = chunks.shift();
         if (chunk === '..') {
             resolved.pop();

package/dist/lib/utils/logger.d.ts

@@ -3,9 +3,9 @@
  * Compatible with the `@prisma/internals` logger and console.
  */
 export interface Logger {
-    log(...data: any[]): void;
-    warn(message: any, ...optionalParams: any[]): void;
-    info(message: any, ...optionalParams: any[]): void;
-    error(message: any, ...optionalParams: any[]): void;
-    query(message: any, ...optionalParams: any[]): void;
+    log(...data: unknown[]): void;
+    warn(message: unknown, ...optionalParams: unknown[]): void;
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    query(message: unknown, ...optionalParams: unknown[]): void;
 }

package/dist/lib/utils/string.d.ts

@@ -2,6 +2,10 @@
  * Returns the same string with a lowercase first letter.
  */
 export declare const uncapitalize: (str: string) => string;
+/**
+ * Returns the same string with an uppercase first letter.
+ */
+export declare const capitalize: (str: string) => string;
 /**
  * Returns the camelCase version of the given string.
  */
@@ -26,4 +30,5 @@ export declare const conjugateNames: (name: string) => {
     camelCase: string;
     pluralized: string;
     uncapitalizedPlural: string;
+    capitalizedPlural: string;
 };

package/dist/lib/utils/string.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.conjugateNames = exports.commentLines = exports.pluralize = exports.toPascalCase = exports.toCamelCase = exports.uncapitalize = void 0;
+exports.conjugateNames = exports.commentLines = exports.pluralize = exports.toPascalCase = exports.toCamelCase = exports.capitalize = exports.uncapitalize = void 0;
 /**
  * Returns the same string with a lowercase first letter.
  */
@@ -8,6 +8,13 @@ const uncapitalize = (str) => {
     return str.charAt(0).toLowerCase() + str.slice(1);
 };
 exports.uncapitalize = uncapitalize;
+/**
+ * Returns the same string with an uppercase first letter.
+ */
+const capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+exports.capitalize = capitalize;
 /**
  * Returns the camelCase version of the given string.
  */
@@ -102,7 +109,8 @@ exports.commentLines = commentLines;
 const conjugateNames = (name) => ({
     PascalCase: (0, exports.toPascalCase)(name),
     camelCase: (0, exports.toCamelCase)(name),
-    pluralized: (0, exports.pluralize)(name),
+    pluralized: (0, exports.capitalize)((0, exports.pluralize)(name)),
     uncapitalizedPlural: (0, exports.uncapitalize)((0, exports.pluralize)(name)),
+    capitalizedPlural: (0, exports.capitalize)((0, exports.pluralize)(name)),
 });
 exports.conjugateNames = conjugateNames;

package/dist/prisma/attributes.js

@@ -30,26 +30,33 @@ function parseAttributesFromDocumentation({ documentation }) {
 }
 exports.parseAttributesFromDocumentation = parseAttributesFromDocumentation;
 function parseArgumentToStringOrStringArray(str) {
-    if (str === '')
+    if (str === '') {
         return '';
+    }
     try {
         return JSON.parse(str);
     }
-    catch (_a) { }
+    catch (_a) {
+        // ignore
+    }
     try {
         return JSON.parse(`[${str}]`);
     }
-    catch (_b) { }
+    catch (_b) {
+        // ignore
+    }
     try {
         return JSON.parse(`"${str}"`);
     }
-    catch (_c) { }
+    catch (_c) {
+        // ignore
+    }
     throw new Error(`Could not parse attribute argument: ${str}`);
 }
 exports.parseArgumentToStringOrStringArray = parseArgumentToStringOrStringArray;
 const blankStringBooleanDecoder = zod_1.default
     .string()
-    .transform((str) => true)
+    .transform(() => true)
     .or(zod_1.default.boolean())
     .optional()
     .default(false);
@@ -84,9 +91,10 @@ function getModelAttributes(model) {
     }));
     const result = decoder.safeParse(attributes);
     if (!result.success) {
-        throw new Error(`Model ${model.name} has invalid model attributes: ${result.error}`);
+        throw new Error(`Model ${model.name} has invalid model attributes: ${result.error.toString()}`);
     }
     if (result.data.description === 'The calculated metric value for a dataset.') {
+        // TODO: What is this supposed to do?
     }
     return result.data;
 }
@@ -99,10 +107,13 @@ function getFieldAttributes(field) {
     if (attributes.examples === undefined && attributes.example !== undefined) {
         attributes.examples = attributes.example;
     }
+    // Prisma also has an "@ignore" attribute - see https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#ignore
+    // we handle this the same way as our custom "ignore" attribute
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const isPrismaIgnored = field.isIgnored === true;
+    const isPXLIgnored = Object.hasOwn(attributes, 'ignore');
     return {
-        // Prisma also has an "@ignore" attribute - see https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#ignore
-        // we handle this the same way as our custom "ignore" attribute
-        ignore: field.isIgnored || Object.hasOwn(attributes, 'ignore'),
+        ignore: isPrismaIgnored || isPXLIgnored,
         description: attributes.description && (0, remeda_1.isString)(attributes.description) ? attributes.description : undefined,
         isDefaultField: Object.hasOwn(attributes, 'isDefault'),
         isLabel: Object.hasOwn(attributes, 'isLabel'),

package/dist/prisma/parse.js

@@ -237,6 +237,7 @@ function getTsTypeForScalar(field) {
         case 'JSON':
         case 'Bytes':
             (0, error_1.throwError)('Not implemented yet');
+            break;
         default:
             // return field.type
             (0, error_1.throwError)(`Investigate: 'default' case in getTypescriptType for field ${field.name} of type ${field.type}`);
@@ -273,6 +274,7 @@ function getTsTypeForEnum(field) {
         case 'Float':
         case 'Int':
             (0, error_1.throwError)(`The enum field ${field.name}  is of type ${field.type} - but only String fields are supported for enums so far.`);
+            break;
         default:
             return Types.toTypeName(field.type);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -17,11 +17,12 @@
     "@faker-js/faker": "7.6.0",
     "@prisma/generator-helper": "4.12.0",
     "@prisma/internals": "^4.12.0",
+    "exceljs": "^4.3.0",
     "fast-glob": "^3.2.12",
     "prettier": "^2.8.7",
     "remeda": "1.9.4",
     "zod": "3.21.4",
-    "@postxl/lock": "0.3.1"
+    "@postxl/lock": "0.3.2"
   },
   "devDependencies": {
     "@prisma/client": "4.12.0",