@postxl/generator 0.33.4 → 0.35.0

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

@@ -23,6 +23,10 @@ export type SchemaConfig = {
          * If true, data module will not be generated.
          */
         data: boolean;
+        /**
+         * If true, actions module will not be generated.
+         */
+        actions: boolean;
         /**
          * If true, business logic module will not be generated.
          */
@@ -59,6 +63,13 @@ export type SchemaConfig = {
          * Path to the directory containing Cypress project.
          */
         cypressPath: Types.Path;
+        /**
+         * Path to the directory containing actions.
+         *
+         * NOTE: Metadata assumes that project is set up so that certain parts of the code
+         * may reference actions using `@project/actions` import.
+         */
+        actionsPath: Types.Path;
         /**
          * Path to the directory containing business logic.
          *
@@ -67,12 +78,19 @@ export type SchemaConfig = {
          */
         businessLogicPath: Types.Path;
         /**
-         * Path to the directory containing mock data samples.
+         * Path to the directory containing seed module.
          *
          * NOTE: Metadata assumes that project is set up so that certain parts of the code
          * may reference mock data using `@project/seed` import.
          */
-        seedPath: Types.Path;
+        seedLibPath: Types.Path;
+        /**
+         * Path to the directory containing mock data samples.
+         *
+         * NOTE: Metadata assumes that project is set up so that certain parts of the code
+         * may reference mock data using `@project/seed-data` import.
+         */
+        seedDataPath: Types.Path;
         /**
          * Path to the directory containing React components.
          *
@@ -89,14 +107,14 @@ export type SchemaConfig = {
          */
         migrationsFolderPath: Types.Path;
     };
-    /**
-     * Seed to use for random generation.
-     */
-    randomSeed: number;
     /**
      * Whether the generator should overwrite existing files.
      */
     force: boolean;
+    /**
+     * Name of the User type
+     */
+    userType: Types.TypeName;
 };
 export type Model = Prettify<ModelCore & ModelFields>;
 /**
@@ -148,6 +166,14 @@ export type ModelFields = {
      * The id field of the model
      */
     idField: FieldId;
+    /**
+     * The field of the model that identifies when the entry was created.
+     */
+    createdAtField?: FieldScalar;
+    /**
+     * The field of the model that identifies when the entry was last updated.
+     */
+    updatedAtField?: FieldScalar;
     /**
      * The property of the model that identifies the default row.
      */

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

@@ -70,3 +70,7 @@ export type Path = string & {
  * Converts a string to a branded FileName.
  */
 export declare const toPath: (t: string) => Path;
+/**
+ * Branded string values that can be used as import statement values in the generators
+ */
+export type ImportableTypes = Fnction | ClassName | TypeName | VariableName;

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

@@ -0,0 +1,29 @@
+/**
+ * A collection of utility functions that let you more easily write TypeScript code.
+ */
+/**
+ * Utility function that lets you easily create a TypeScript switch statement.
+ */
+export declare function createSwitchStatement({ field, cases, defaultBlock, }: {
+    /**
+     * The variable name to switch on.
+     */
+    field: string;
+    /**
+     * The cases to switch on.
+     */
+    cases: {
+        /**
+         * The value to match.
+         */
+        match: string;
+        /**
+         * The body of the switch case.
+         */
+        block: string;
+    }[];
+    /**
+     * The execution block of the default case.
+     */
+    defaultBlock?: string;
+}): string;

package/dist/lib/utils/ast.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * A collection of utility functions that let you more easily write TypeScript code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSwitchStatement = void 0;
+/**
+ * Utility function that lets you easily create a TypeScript switch statement.
+ */
+function createSwitchStatement({ field, cases, defaultBlock, }) {
+    const _cases = cases.map(_createSwitchCase).join('\n');
+    const _default = defaultBlock ? `default: {\n${defaultBlock}\n}` : '';
+    return `
+switch (${field}) {
+	${_cases}
+	${_default}
+}
+	`;
+}
+exports.createSwitchStatement = createSwitchStatement;
+function _createSwitchCase({ match, block, }) {
+    return `case ${match}: {\n${block}\n}`;
+}

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

@@ -1,4 +1,4 @@
 /**
  * Returns a string of JSDoc comments from an array of lines.
  */
-export declare function convertToJsDocComments(comments: string[]): string;
+export declare function toJsDocComment(comments: string[] | undefined): string;

package/dist/lib/utils/jsdoc.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToJsDocComments = void 0;
+exports.toJsDocComment = void 0;
 /**
  * Returns a string of JSDoc comments from an array of lines.
  */
-function convertToJsDocComments(comments) {
-    return comments
+function toJsDocComment(comments) {
+    if (!comments || comments.length === 0) {
+        return '';
+    }
+    return `/**${comments
         .filter((c) => c !== '')
         .map((c) => `\n   * ${c}`)
-        .join('');
+        .join('')} \n   */`;
 }
-exports.convertToJsDocComments = convertToJsDocComments;
+exports.toJsDocComment = toJsDocComment;

package/dist/lib/utils/string.js

@@ -70,8 +70,9 @@ const irregularPlurals = {
  * Returns a pluralized version of the given string based on the count.
  */
 const pluralize = (s, count = 2) => {
-    if (count === 1)
+    if (count === 1) {
         return s;
+    }
     if (s.endsWith('y') &&
         !s.endsWith('ay') &&
         !s.endsWith('ey') &&

package/dist/prisma/attributes.js

@@ -4,24 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFieldAttributes = exports.getEnumAttributes = exports.getModelAttributes = exports.parseArgumentToStringOrStringArray = exports.parseAttributesFromDocumentation = void 0;
-const remeda_1 = require("remeda");
-const string_1 = require("../lib/utils/string");
 const zod_1 = __importDefault(require("zod"));
+const string_1 = require("../lib/utils/string");
 /**
  * Parses attributes from a given string using provided prefix.
  */
 function parseAttributesFromDocumentation({ documentation }) {
     const prefix = '@@';
-    if (!documentation)
+    if (!documentation) {
         return {};
+    }
     return documentation
         .split('\n')
         .filter((d) => d.startsWith(prefix))
         .map((d) => d.replace(prefix, ''))
         .reduce((acc, line) => {
         const pattern = /(\w+)\((.*?)\)$/;
-        if (!pattern.test(line))
+        if (!pattern.test(line)) {
             return acc;
+        }
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const [attribute, arg] = line.match(pattern).slice(1);
         acc[(0, string_1.toCamelCase)(attribute)] = parseArgumentToStringOrStringArray(arg);
@@ -72,6 +73,7 @@ function getModelAttributes(model) {
         description: zod_1.default.string().optional(),
         schema: zod_1.default.string().optional(),
         index: zod_1.default.array(zod_1.default.string()).optional(),
+        seed: zod_1.default.string().optional(),
     })
         .transform((obj) => ({
         ignore: obj.ignore,
@@ -79,6 +81,7 @@ function getModelAttributes(model) {
         description: obj.description,
         databaseSchema: obj.schema,
         index: obj.index,
+        randomSeed: obj.seed !== undefined ? parseInt(obj.seed, 10) : undefined,
     }));
     const result = decoder.safeParse(attributes);
     if (!result.success) {
@@ -113,31 +116,47 @@ exports.getEnumAttributes = getEnumAttributes;
  */
 function getFieldAttributes(field) {
     const attributes = parseAttributesFromDocumentation(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 {
-        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'),
-        examples: !attributes.examples
-            ? undefined
-            : Array.isArray(attributes.examples)
-                ? attributes.examples
-                : [attributes.examples],
-        maxLength: Object.hasOwn(attributes, 'maxLength')
-            ? (0, remeda_1.isString)(attributes.maxLength)
-                ? parseInt(attributes.maxLength, 10)
-                : (0, remeda_1.isNumber)(attributes.maxLength)
-                    ? attributes.maxLength
-                    : undefined
-            : undefined,
-    };
+    const exampleDecoder = zod_1.default.union([zod_1.default.string(), zod_1.default.number(), zod_1.default.boolean(), zod_1.default.null()]);
+    const examplesDecoder = exampleDecoder
+        .transform((obj) => [obj])
+        .or(zod_1.default.array(exampleDecoder))
+        .optional();
+    const decoder = zod_1.default
+        .object({
+        ignore: blankStringBooleanDecoder,
+        description: zod_1.default.string().optional(),
+        isDefault: blankStringBooleanDecoder,
+        label: blankStringBooleanDecoder,
+        example: examplesDecoder,
+        examples: examplesDecoder,
+        maxLength: zod_1.default
+            .number()
+            .or(zod_1.default.string().transform((s) => parseInt(s, 10)))
+            .optional(),
+        readonly: blankStringBooleanDecoder,
+    })
+        .transform((obj) => {
+        var _a;
+        return ({
+            ignore: obj.ignore || isPrismaIgnored,
+            description: obj.description,
+            isDefaultField: obj.isDefault,
+            isLabel: obj.label,
+            examples: obj.examples || obj.example,
+            maxLength: obj.maxLength,
+            isReadonly: obj.readonly || field.isGenerated || field.isUpdatedAt || field.name === 'createdAt' || field.isId,
+            isUpdatedAt: (_a = field.isUpdatedAt) !== null && _a !== void 0 ? _a : false,
+            isCreatedAt: field.name === 'createdAt',
+        });
+    });
+    const result = decoder.safeParse(attributes);
+    if (!result.success) {
+        throw new Error(`Field ${field.name} has invalid field attributes: ${result.error.toString()}`);
+    }
+    return result.data;
 }
 exports.getFieldAttributes = getFieldAttributes;

package/dist/prisma/parse.js

@@ -28,19 +28,34 @@ const Types = __importStar(require("../lib/schema/types"));
 const error_1 = require("../lib/utils/error");
 const string_1 = require("../lib/utils/string");
 const attributes_1 = require("./attributes");
+/**
+ * These models are required for the generators/backend to work.
+ */
+const REQUIRED_MODELS = ['User', 'Config', 'File', 'Action', 'Mutation'];
 /**
  * Converts a Prisma schema (DMMF) document to a Schema that's passed around generators.
  */
 function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }) {
+    ensureRequiredModelsExists(modelsRaw);
     // NOTE: We preprocess models and enums so that we can populate relationships.
     const models = modelsRaw.map((dmmfModel) => parseModelCore({ dmmfModel, config }));
     const enums = enumsRaw.map((dmmfEnum) => parseEnum({ dmmfEnum, config }));
     const modelsWithFields = modelsRaw
         .map((dmmfModel) => parseModel({ dmmfModel, models, enums, config }))
-        .filter((model) => !model.attributes.ignore);
+        .filter(isModelNotIgnored);
     return { models: modelsWithFields, enums };
 }
 exports.parsePrismaSchema = parsePrismaSchema;
+function ensureRequiredModelsExists(models) {
+    for (const requiredModel of REQUIRED_MODELS) {
+        if (!models.find((m) => m.name === requiredModel)) {
+            (0, error_1.throwError)(`Required model ${requiredModel} not found in schema!`);
+        }
+    }
+}
+function isModelNotIgnored(model) {
+    return model !== undefined && !model.attributes.ignore;
+}
 /**
  * Parses the core properties of a model without fields.
  */
@@ -63,6 +78,10 @@ function parseModelCore({ dmmfModel, config, }) {
  */
 function parseModel({ dmmfModel, enums, models, config, }) {
     const core = parseModelCore({ dmmfModel, config });
+    // NOTE: We ignore models which are marked as ignored.
+    if (core.attributes.ignore) {
+        return undefined;
+    }
     // NOTE: We assume that each relation may only reference one field. Because of this,
     // we can "relate" a given relation to a scalar field used in the relation.
     //   Since Prisma doesn't mark those fields as relations, we need to preprocess
@@ -146,17 +165,21 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         (0, error_1.throwError)(`Investigate: Field ${shared.sourceName}.${shared.sourceName} is not scalar, enum nor relation.`);
     })
         .filter((field) => !isFieldIgnored({ field }));
-    const { idField, defaultField, nameField } = validateFields({ fields, model: core });
+    const { idField, defaultField, nameField, createdAtField, updatedAtField } = validateFields({ fields, model: core });
     return Object.assign(Object.assign({}, core), { idField,
         defaultField,
         nameField,
-        fields });
+        fields,
+        createdAtField,
+        updatedAtField });
 }
 /**
  * Checks that there is exactly one id field and that there is at most one default field.
  */
 function validateFields({ fields, model: { name } }) {
     let idField = undefined;
+    let createdAtField = undefined;
+    let updatedAtField = undefined;
     let nameField = undefined;
     let nameFieldFallback = undefined;
     let defaultField = undefined;
@@ -166,6 +189,18 @@ function validateFields({ fields, model: { name } }) {
                 if (field.name === 'name') {
                     nameFieldFallback = field;
                 }
+                if (field.attributes.isCreatedAt) {
+                    if (createdAtField) {
+                        throw new Error(`❌❌❌ Model ${name} has multiple createdAt fields`);
+                    }
+                    createdAtField = field;
+                }
+                if (field.attributes.isUpdatedAt) {
+                    if (updatedAtField) {
+                        throw new Error(`❌❌❌ Model ${name} has multiple updatedAt fields`);
+                    }
+                    updatedAtField = field;
+                }
                 break;
             case 'id':
                 if (idField) {
@@ -199,7 +234,7 @@ function validateFields({ fields, model: { name } }) {
     if (!nameField && nameFieldFallback) {
         nameField = nameFieldFallback;
     }
-    return { idField, defaultField, nameField };
+    return { idField, defaultField, nameField, createdAtField, updatedAtField };
 }
 function isAutoIncrementField(fieldDmmf) {
     if (fieldDmmf.default === undefined) {
@@ -232,9 +267,6 @@ function isUniqueField(fieldRaw) {
  * Tells whether the parsed schema should skip a given field.
  */
 function isFieldIgnored({ field }) {
-    if (field.name === 'createdAt' || field.name === 'updatedAt' || field.name === 'deletedAt') {
-        return true;
-    }
     if (Object.hasOwn(field.attributes, 'ignore') && field.attributes.ignore) {
         return true;
     }
@@ -274,13 +306,14 @@ function getTsTypeForScalar(field) {
         case 'Float':
         case 'Int':
             return Types.toTypeName('number');
-        case 'JSON':
+        case 'Json':
         case 'Bytes':
             (0, error_1.throwError)('Not implemented yet');
-            break;
+        // While TypeScript understands that throwError never returns, eslint doesn't and complains.
+        // Hence we ignore the fallthrough error.
+        // eslint-disable-next-line no-fallthrough
         default:
-            // return field.type
-            (0, error_1.throwError)(`Investigate: 'default' case in getTypescriptType for field ${field.name} of type ${field.type}`);
+            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${field.name} of type ${field.type}`);
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.33.4",
+  "version": "0.35.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateBusinessLogicIndex = void 0;
-const exports_1 = require("../../lib/exports");
-const meta_1 = require("../../lib/meta");
-/**
- * Generates index file for all businessLogic files.
- */
-function generateBusinessLogicIndex({ models, meta }) {
-    const exports = exports_1.ExportsGenerator.from(meta.businessLogic.indexFilePath);
-    exports.exportEverythingFromPath(meta.businessLogic.serviceFilePath);
-    exports.exportEverythingFromPath(meta.businessLogic.moduleFilePath);
-    for (const model of models) {
-        const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.businessLogic.serviceFilePath);
-    }
-    return exports.generate();
-}
-exports.generateBusinessLogicIndex = generateBusinessLogicIndex;

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSeedIndex = void 0;
-const exports_1 = require("../../lib/exports");
-const meta_1 = require("../../lib/meta");
-/**
- * Generates index file for all seed files.
- */
-function generateSeedIndex({ models, meta }) {
-    const exports = exports_1.ExportsGenerator.from(meta.seed.indexFilePath);
-    for (const model of models) {
-        const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.seed.filePath);
-    }
-    return exports.generate();
-}
-exports.generateSeedIndex = generateSeedIndex;

package/dist/generators/indices/testdataservice.generator.d.ts

@@ -1,9 +0,0 @@
-import { SchemaMetaData } from '../../lib/meta';
-import { Model } from '../../lib/schema/schema';
-/**
- * Generates a generic data service object that may be used on the server to access database.
- */
-export declare function generateTestDataService({ meta, models }: {
-    meta: SchemaMetaData;
-    models: Model[];
-}): string;

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

@@ -1,78 +0,0 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTestDataService = void 0;
-const meta_1 = require("../../lib/meta");
-const Types = __importStar(require("../../lib/schema/types"));
-const imports_1 = require("../../lib/imports");
-/**
- * Generates a generic data service object that may be used on the server to access database.
- */
-function generateTestDataService({ meta, models }) {
-    const imports = imports_1.ImportsGenerator.from(meta.data.testDataServiceFilePath).addImport({
-        items: [Types.toVariableName('MockData')],
-        from: meta.data.dataMockModuleFilePath,
-    });
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    for (const { meta } of mm) {
-        imports.addImport({
-            items: [meta.data.repositoryClassName],
-            from: meta.data.repoFilePath,
-        });
-    }
-    const constructor = mm
-        .map(({ meta }) => `private ${meta.data.dataServiceName} :${meta.data.repositoryClassName}`)
-        .join(',\n');
-    return `
-		import { Injectable, Logger } from '@nestjs/common'
-
-		import { ResetService } from '@pxl/common'
-		import { DbService } from '@${meta.config.project}/db'
-
-		${imports.generate()}
-
-		@Injectable()
-		export class TestDataService {
-			private logger = new Logger(TestDataService.name)
-			constructor(
-				private db: DbService,
-				private resetService: ResetService,
-				${constructor}
-			) {}
-
-			public async resetTestData(data: MockData) {
-				this.logger.log(\`✅ Reset test data\`)
-				await this.db.emptyDatabase()
-
-				${mm
-        .map(({ meta }) => `await this.${meta.data.dataServiceName}.reInit(data.${meta.data.mockDataPropertyName} ?? [])`)
-        .join('\n')}
-				
-					return this.resetService.reset()
-			}
-		}
-	`;
-}
-exports.generateTestDataService = generateTestDataService;

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

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