@postxl/generator 0.69.1 → 0.70.0

package/README.md

@@ -1,22 +1,3 @@
 # PXL Generator
 
-A utility package that lets you move quickly and generate basic components of your app easily.
-
-#### Linking Generator to Template
-
-To use the latest version of the generator link the local dependency using [`pnpm link`](https://pnpm.io/cli/link) command.
-
-```sh
-# /
-pnpm build
-
-# /packages/manager/template/
-pnpm link ../../generator/
-
-# /
-pnpm prisma generate
-```
-
-> If you've correctly linked the generator, you should see a message when running `pnpm i`.
-
-![pnpm link](./media/link.png)
+> A utility package that lets you move quickly and generate basic components of your app easily.

package/dist/generator.js

@@ -50,7 +50,7 @@ const importexport_exporter_class_generator_1 = require("./generators/indices/im
 const importexport_import_service_generator_1 = require("./generators/indices/import-export/importexport-import-service.generator");
 const importexport_types_generator_1 = require("./generators/indices/import-export/importexport-types.generator");
 const repositories_generator_1 = require("./generators/indices/repositories.generator");
-const routes_index_generator_1 = require("./generators/indices/routes-index.generator");
+const routes_generator_1 = require("./generators/indices/routes.generator");
 const seed_migration_generator_1 = require("./generators/indices/seed-migration.generator");
 const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
 const testids_generator_1 = require("./generators/indices/testids.generator");
@@ -116,7 +116,7 @@ const CONFIG_SCHEMA = zod_1.z
             prismaMigrationsFolderPath: (0, types_1.toPath)(s.prismaMigrationsFolder || './migrations'),
             modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || './backend/libs/types/src/'),
             reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || './web/src/components/'),
-            seedDataPath: (0, types_1.toPath)(s.pathToSeedData || './backend/seed-data/src/'),
+            seedDataPath: (0, types_1.toPath)(s.pathToSeedData || './backend/libs/seed-data/src/'),
             seedLibPath: (0, types_1.toPath)(s.pathToSeedLib || './backend/libs/seed/src/'),
             trpcRoutesFolderPath: (0, types_1.toPath)(s.trpcRoutesFolder || './backend/libs/trpc/src/routes/'),
             adminPagesFolderPath: (0, types_1.toPath)(s.pathToAdminPages || './web/src/pages/admin/'),
@@ -135,7 +135,7 @@ const CONFIG_SCHEMA = zod_1.z
             prettyName: `PXL`,
         };
     },
-    onGenerate: ({ generator, otherGenerators, dmmf }) => __awaiter(void 0, void 0, void 0, function* () {
+    onGenerate: (_a) => __awaiter(void 0, [_a], void 0, function* ({ generator, otherGenerators, dmmf }) {
         internals_1.logger.info(`PXL started generating code...`);
         const prismaClientPath = (0, client_path_1.getClientImportPath)(otherGenerators);
         const decodedConfig = CONFIG_SCHEMA.safeParse(generator.config);
@@ -153,8 +153,8 @@ const CONFIG_SCHEMA = zod_1.z
 /**
  * Generates PXL files and flushes them to disk.
  */
-function generate({ models, enums, config, prismaClientPath, logger, }) {
-    return __awaiter(this, void 0, void 0, function* () {
+function generate(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ models, enums, config, prismaClientPath, logger, }) {
         const root = yield lock_1.LockFile.findProjectRoot();
         if (root == undefined) {
             throw new Error(`Could not find lock file. Make sure you are running the generator in a project folder.`);
@@ -172,7 +172,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.data.stubLocation.path}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
             generated.write(`/${meta.data.repository.location.path}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
             // Import-Export
-            generated.write(`/${meta.importExport.decoder.filePath}.ts`, (0, importexport_decoder_generator_1.generateModelImportExportDecoder)({ model, meta, schemaMeta: (0, meta_1.getSchemaMetadata)({ config }) }));
+            generated.write(`/${meta.importExport.decoder.filePath}.ts`, (0, importexport_decoder_generator_1.generateModelImportExportDecoder)({ model, meta }));
             // Business Logic
             generated.write(`/${meta.view.serviceLocation.path}.ts`, (0, service_generator_5.generateModelBusinessLogicView)({ model, meta }));
             generated.write(`/${meta.update.serviceClassLocation.path}.ts`, (0, service_generator_4.generateModelBusinessLogicUpdate)({ model, meta }));
@@ -217,7 +217,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         generated.write(`/${meta.seedData.initialMigrationLocation.path}.ts`, (0, seed_migration_generator_1.generateSeedMigration)({ models, meta }));
         generated.write(`/${meta.seedData.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
         // Routes
-        generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, routes_index_generator_1.generateRoutesIndex)({ models, meta }));
+        generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, routes_generator_1.generateRoutesIndex)({ models, meta }));
         // Types
         generated.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_3.generateTypesIndex)({ models, enums, meta }));
         // -------------------------------------------------------------------------

package/dist/generators/indices/{routes-index.generator.js → routes.generator.js}

@@ -14,11 +14,14 @@ function generateRoutesIndex({ models, meta }) {
     }
     return /* ts */ `
       ${imports.generate()}
+
+      import { viewer } from './viewer.router'
   
       /**
        * Object with all generated routes.
        */
       export const routes = {
+        viewer,
         ${mm.map(({ meta }) => `${meta.trpc.routerName}`).join(',\n')}
       }
     `;

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

@@ -39,8 +39,8 @@ 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* () {
+function generateSeedExcelTemplate(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ models }) {
         const wb = initializeWorkbook();
         for (const model of [...models].sort((a, b) => a.name.localeCompare(b.name))) {
             const meta = (0, meta_1.getModelMetadata)({ model });

package/dist/generators/models/importexport-decoder.generator.d.ts

@@ -3,10 +3,9 @@ import { Model } from '../../lib/schema/schema';
 /**
  * Creates a decoder for the Seed Excel template.
  */
-export declare function generateModelImportExportDecoder({ model, meta, schemaMeta, }: {
+export declare function generateModelImportExportDecoder({ model, meta }: {
     model: Model;
     meta: ModelMetaData;
-    schemaMeta: SchemaMetaData;
 }): string;
 /**
  * Generates the data decoder, aggregating all the models.

package/dist/generators/models/importexport-decoder.generator.js

@@ -5,17 +5,18 @@ const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const types_1 = require("../../lib/schema/types");
 const types_2 = require("../../lib/types");
+const zodPackageName = (0, types_1.toPackageName)('@postxl/zod');
 /**
  * Creates a decoder for the Seed Excel template.
  */
-function generateModelImportExportDecoder({ model, meta, schemaMeta, }) {
+function generateModelImportExportDecoder({ model, meta }) {
     const { filePath: decoderFilePath, itemEncoderFunctionName: rowExportFunctionName, encodedExcelType: excelType, arrayEncoderFunctionName: tableExportFunctionName, tableDecoder: tableImportDecoder, } = meta.importExport.decoder;
     const imports = imports_1.ImportsGenerator.from(decoderFilePath).addImports({
-        [schemaMeta.backendModules.common.importPath]: [schemaMeta.backendModules.common.functions.excelNullOrBlankDecoder],
+        [zodPackageName]: [(0, types_1.toFunctionName)('excelNullOrBlankDecoder')],
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
     });
     const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural, internalSingularName: singular, internalSingularNameCapitalized: singularCapitalized, } = meta;
-    const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, schemaMeta, imports });
+    const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, imports });
     return `
 import * as z from 'zod'
 
@@ -72,7 +73,7 @@ export const ${tableExportFunctionName} = (items: ${model.typeName}[]): ${excelT
   `;
 }
 exports.generateModelImportExportDecoder = generateModelImportExportDecoder;
-function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
+function generateFieldDecoders({ model, meta, imports, }) {
     const fieldDecoders = [];
     const blankFieldDecoders = [];
     for (const field of model.fields) {
@@ -84,20 +85,16 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
                 imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     tsTypeName: field.unbrandedTypeName,
-                    dbTypeName: field.schemaType,
                     nullable: false,
                     imports,
-                    schemaMeta,
                 })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
                 break;
             }
             case 'scalar': {
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     tsTypeName: field.tsTypeName,
-                    dbTypeName: field.schemaType,
                     nullable: !field.isRequired,
                     imports,
-                    schemaMeta,
                 })}${optionalModifier}`);
                 break;
             }
@@ -107,10 +104,8 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
                 imports.addImport({ items: [refMeta.types.toBrandedIdTypeFnName], from: refMeta.types.importPath });
                 fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
                     tsTypeName: field.unbrandedTypeName,
-                    dbTypeName: field.schemaType,
                     nullable: !field.isRequired,
                     imports,
-                    schemaMeta,
                 })}
           .transform(
             (id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => 
@@ -131,50 +126,26 @@ function generateFieldDecoders({ model, meta, schemaMeta, imports, }) {
     }
     return { fieldDecoders, blankFieldDecoders };
 }
-function toExcelDecoder({ tsTypeName, 
-// We will use the DB type later when extending the number decoder
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-dbTypeName, nullable, imports, schemaMeta, }) {
+function toExcelDecoder({ tsTypeName, nullable, imports, }) {
     switch (tsTypeName) {
         case 'string': {
-            const decoder = schemaMeta.backendModules.common.functions[nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder'];
-            imports.addImport({ items: [decoder], from: schemaMeta.backendModules.common.importPath });
+            const decoder = nullable ? (0, types_1.toFunctionName)('excelStringNullableDecoder') : (0, types_1.toFunctionName)('excelStringDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
+            return decoder;
+        }
+        case 'boolean': {
+            const decoder = (0, types_1.toFunctionName)('excelBooleanDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
             return decoder;
         }
-        case 'boolean':
-            imports.addImport({
-                items: [schemaMeta.backendModules.common.functions.excelBooleanDecoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
-            return 'excelBooleanDecoder';
         case 'number': {
-            let decoder;
-            switch (dbTypeName) {
-                case 'Int':
-                    decoder =
-                        schemaMeta.backendModules.common.functions[nullable ? 'excelNumberNullableDecoder' : 'excelNumberDecoder'];
-                    break;
-                case 'BigInt':
-                    decoder =
-                        schemaMeta.backendModules.common.functions[nullable ? 'excelNumberNullableDecoder' : 'excelNumberDecoder'];
-                    break;
-                default:
-                    decoder =
-                        schemaMeta.backendModules.common.functions[nullable ? 'excelNumberNullableDecoder' : 'excelNumberDecoder'];
-                    break;
-            }
-            imports.addImport({
-                items: [decoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
+            const decoder = nullable ? (0, types_1.toFunctionName)('excelNumberNullableDecoder') : (0, types_1.toFunctionName)('excelNumberDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
             return decoder;
         }
         case 'Date': {
-            const decoder = schemaMeta.backendModules.common.functions[nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder'];
-            imports.addImport({
-                items: [decoder],
-                from: schemaMeta.backendModules.common.importPath,
-            });
+            const decoder = nullable ? (0, types_1.toFunctionName)('excelDateNullableDecoder') : (0, types_1.toFunctionName)('excelDateDecoder');
+            imports.addImport({ items: [decoder], from: zodPackageName });
             return decoder;
         }
         default:

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

@@ -33,7 +33,7 @@ function generateRepository({ model, meta }) {
     const uniqueStringFieldsBlocks = generateUniqueFieldsBlocks({ model, meta });
     const maxLengthBlocks = generateMaxLengthBlocks({ model, meta });
     const validationBlocks = generateValidationBlocks({ model, meta });
-    const indexBlocks = generateIndexBlocks({ model, schemaMeta, meta, imports });
+    const indexBlocks = generateIndexBlocks({ model, imports });
     const relationsBlocks = generateRelationsBlocks({ model, meta, imports });
     imports.addImports({
         [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
@@ -828,10 +828,10 @@ function generateValidationBlocks({ model }) {
     }
     return result;
 }
-function generateIndexBlocks({ model, imports, schemaMeta, }) {
+function generateIndexBlocks({ model, imports }) {
     const indexes = model.attributes.index ? [getIndexDefinition({ fieldNames: model.attributes.index, model })] : [];
     if (indexes.length > 0) {
-        imports.addTypeImport({ items: [(0, types_1.toTypeName)('NestedMap')], from: schemaMeta.backendModules.common.importPath });
+        imports.addTypeImport({ from: (0, types_1.toPackageName)('@postxl/runtime'), items: [(0, types_1.toTypeName)('NestedMap')] });
     }
     const result = {
         nestedMapDeclarations: [],

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

@@ -27,7 +27,7 @@ function generateRoute({ model, meta }) {
     });
     return /* ts */ `
 import { z } from 'zod'
-import { procedure, router } from '../trpc'
+import { authMiddleware, procedure, router } from '../trpc'
 
 ${imports.generate()}
 
@@ -64,18 +64,22 @@ export const ${meta.trpc.routerName} = router({
     }),
 
     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})),
 })

package/dist/lib/meta.d.ts

@@ -8,29 +8,6 @@ export type SchemaMetaData = {
      * Static meta data for the backend modules that are not generated
      */
     backendModules: {
-        common: {
-            /**
-             * Path that may be used to import the common backend module.
-             */
-            importPath: Types.BackendModulePath;
-            /**
-             * Names of the functions that are provided by the common backend module.
-             */
-            functions: {
-                excelNullOrBlankDecoder: Types.FunctionName;
-                excelStringNullableDecoder: Types.FunctionName;
-                excelStringDecoder: Types.FunctionName;
-                excelNumberNullableDecoder: Types.FunctionName;
-                excelNumberDecoder: Types.FunctionName;
-                excelIntDecoder: Types.FunctionName;
-                excelIntNullableDecoder: Types.FunctionName;
-                excelBigIntDecoder: Types.FunctionName;
-                excelBigIntNullableDecoder: Types.FunctionName;
-                excelDateNullableDecoder: Types.FunctionName;
-                excelDateDecoder: Types.FunctionName;
-                excelBooleanDecoder: Types.FunctionName;
-            };
-        };
         auth: {
             /**
              * Path that may be used to import the auth backend module.

package/dist/lib/meta.js

@@ -32,23 +32,6 @@ const string_1 = require("./utils/string");
 function getSchemaMetadata({ config }) {
     return {
         backendModules: {
-            common: {
-                importPath: Types.toBackendModulePath(`@backend/common`),
-                functions: {
-                    excelNullOrBlankDecoder: Types.toFunctionName(`excelNullOrBlankDecoder`),
-                    excelStringNullableDecoder: Types.toFunctionName(`excelStringNullableDecoder`),
-                    excelStringDecoder: Types.toFunctionName(`excelStringDecoder`),
-                    excelNumberNullableDecoder: Types.toFunctionName(`excelNumberNullableDecoder`),
-                    excelNumberDecoder: Types.toFunctionName(`excelNumberDecoder`),
-                    excelIntDecoder: Types.toFunctionName(`excelIntDecoder`),
-                    excelIntNullableDecoder: Types.toFunctionName(`excelIntNullableDecoder`),
-                    excelBigIntDecoder: Types.toFunctionName(`excelBigIntDecoder`),
-                    excelBigIntNullableDecoder: Types.toFunctionName(`excelBigIntNullableDecoder`),
-                    excelDateNullableDecoder: Types.toFunctionName(`excelDateNullableDecoder`),
-                    excelDateDecoder: Types.toFunctionName(`excelDateDecoder`),
-                    excelBooleanDecoder: Types.toFunctionName(`excelBooleanDecoder`),
-                },
-            },
             auth: {
                 importPath: Types.toBackendModulePath(`@backend/auth`),
             },

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

@@ -14,7 +14,7 @@ export declare const getDefaultField: ({ fields }: {
  */
 export declare const getScalarFields: ({ fields, tsTypeName }: {
     fields: Field[];
-    tsTypeName?: string | undefined;
+    tsTypeName?: string;
 }) => FieldScalar[];
 /**
  * List of all relation fields of the model.

package/dist/lib/zod.d.ts

@@ -4,5 +4,5 @@ import { Field } from './schema/schema';
  */
 export declare const getZodDecoderDefinition: ({ field, allowAnyOptionalField, }: {
     field: Field;
-    allowAnyOptionalField?: boolean | undefined;
+    allowAnyOptionalField?: boolean;
 }) => string;

package/dist/prisma/parse.js

@@ -65,7 +65,7 @@ exports.parsePrismaSchema = parsePrismaSchema;
 /**
  * These models are required for the generators/backend to work.
  */
-const SYSTEM_MODELS = ['User', 'Config', 'File', 'Action', 'Mutation'];
+const SYSTEM_MODELS = ['User', 'File', 'Action', 'Mutation'];
 function ensurePXLSystemModelsExist(models) {
     for (const requiredModel of SYSTEM_MODELS) {
         if (!models.find((m) => m.name === requiredModel)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.69.1",
+  "version": "0.70.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -20,22 +20,22 @@
     "exceljs": "4.3.0",
     "fast-glob": "3.2.12",
     "remeda": "1.9.4",
-    "zod": "3.21.4",
+    "zod": "3.22.2",
     "@postxl/lock": "1.4.1",
     "@postxl/prettier": "0.0.1"
   },
   "devDependencies": {
+    "@jest/globals": "29.7.0",
     "@prisma/client": "5.8.1",
     "@types/eslint": "8.44.7",
-    "@types/jest": "29.5.0",
     "@types/node": "18.15.10",
     "jest": "29.7.0",
     "prisma": "5.8.1",
-    "ts-jest": "29.0.5",
+    "ts-jest": "29.1.3",
     "ts-node": "10.9.1",
     "ts-toolbelt": "9.6.0",
     "tsconfig-paths": "4.1.2",
-    "typescript": "5.2.2"
+    "typescript": "5.4.5"
   },
   "peerDependencies": {
     "prisma": "5.8.1"
@@ -44,9 +44,6 @@
     "autoDetect": true
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepublish": "tsc -p tsconfig.build.json",
-    "dev": "tsc -p tsconfig.build.json -w",
     "test:generators": "./scripts/test.sh",
     "test:jest": "jest",
     "test:watch": "jest --watch",