@postxl/generator 0.29.0 → 0.31.0

package/dist/generator.js

@@ -61,6 +61,7 @@ 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 datamocker_generator_1 = require("./generators/indices/datamocker.generator");
 const businesslogicservice_generator_1 = require("./generators/indices/businesslogicservice.generator");
 const businesslogicindex_generator_1 = require("./generators/indices/businesslogicindex.generator");
 const businesslogicmodule_generator_1 = require("./generators/indices/businesslogicmodule.generator");
@@ -73,6 +74,7 @@ const CONFIG_SCHEMA = zod_1.z
     project: zod_1.z.string(),
     pathToTypes: zod_1.z.string().optional(),
     pathToDataLib: zod_1.z.string().optional(),
+    pathToCypress: zod_1.z.string().optional(),
     pathToBusinessLogic: zod_1.z.string().optional(),
     pathToSeedLib: zod_1.z.string().optional(),
     trpcRoutesFolder: zod_1.z.string().optional(),
@@ -92,6 +94,7 @@ const CONFIG_SCHEMA = zod_1.z
         project: s.project,
         paths: {
             dataLibPath: (0, types_1.toPath)(s.pathToDataLib || 'repos'),
+            cypressPath: (0, types_1.toPath)(s.pathToCypress || './e2e/cypress/'),
             businessLogicPath: (0, types_1.toPath)(s.pathToBusinessLogic || 'repos'),
             reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || 'react'),
             modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || 'types'),
@@ -163,6 +166,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
                 generated.write(`/${meta.data.stubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
                 generated.write(`/${meta.data.repoFilePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
                 generated.write(`/${meta.data.mockRepoFilePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
+                generated.write(`/${meta.data.dataMockerStubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
             }
             // Business Logic
             if (!config.disableGenerators.businessLogic) {
@@ -194,6 +198,8 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.data.dataMockModuleFilePath}.ts`, (0, datamockmodule_generator_1.generateDataMockModule)({ models, meta }));
             generated.write(`/${meta.data.dataModuleFilePath}.ts`, (0, datamodule_generator_1.generateDataModule)({ models, meta }));
             generated.write(`/${meta.data.dataServiceFilePath}.ts`, (0, dataservice_generator_1.generateDataService)({ models, meta }));
+            generated.write(`/${meta.data.dataMockerFilePath}.ts`, (0, datamocker_generator_1.generateDataMocker)({ models, meta }));
+            generated.write(`/${meta.data.dataMockerStubIndexFilePath}.ts`, (0, stubs_generator_1.generateDataMockerStubsIndex)({ models, meta }));
             generated.write(`/${meta.data.testDataServiceFilePath}.ts`, (0, testdataservice_generator_1.generateTestDataService)({ models, meta }));
             generated.write(`/${meta.data.repositoriesConstFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
             generated.write(`/${meta.data.repositoriesIndexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));

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

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates a generic data mocker class.
+ */
+export declare function generateDataMocker({ models, meta: schemaMeta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataMocker = void 0;
+const meta_1 = require("../../lib/meta");
+const schema_1 = require("../../lib/schema/schema");
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates a generic data mocker class.
+ */
+function generateDataMocker({ models, meta: schemaMeta }) {
+    const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(schemaMeta.data.dataMockerFilePath);
+    for (const { model, meta } of modelMetas) {
+        imports.addImport({
+            items: [model.typeName],
+            from: meta.types.importPath,
+        });
+        imports.addImport({
+            items: [meta.data.stubGenerationFnName],
+            from: schemaMeta.data.dataMockerStubImportPath,
+        });
+    }
+    const publicVariables = modelMetas
+        .map(({ model, meta }) => `public ${meta.data.dataServiceName}: ${model.typeName}[] = []`)
+        .join('\n');
+    const privateIds = modelMetas
+        .map(({ model, meta }) => `private ${meta.data.dataServiceIdName}Ids = new IdTracker<${model.typeName}>()`)
+        .join('\n');
+    const addDataFunctions = modelMetas.map(({ model, meta }) => generateAddDataFunction(model, meta)).join('\n');
+    // const timeNow = new Date().toLocaleTimeString('en-US', { hour12: false, hour: 'numeric', minute: 'numeric' })
+    // const todayDate = new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'numeric', day: 'numeric' })
+    return `
+import type { MockData } from '@pxl/data'
+import { IdTracker } from './id-tracker.class'
+${imports.generate()}
+
+export class DataMocker implements MockData {
+  ${publicVariables}
+
+  ${privateIds}
+
+  ${addDataFunctions}
+}
+`;
+}
+exports.generateDataMocker = generateDataMocker;
+// Generated time stamp: ${todayDate} ${timeNow}
+function generateAddDataFunction(model, meta) {
+    const { fields, idField } = model;
+    const relations = fields.filter(schema_1.isFieldRelation).map((field) => (Object.assign(Object.assign({}, field), { meta: (0, meta_1.getModelMetadata)({ model: field.relationToModel }), fieldMeta: (0, meta_1.getFieldMetadata)({ field }), model: field.relationToModel })));
+    return `public add${model.typeName}(item?: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName}}>): DataMocker {
+    const initial${meta.data.dataServiceIdName} = stub${model.typeName}(item ?? {})
+    this.${meta.data.dataServiceName}.push(this.${meta.data.dataServiceIdName}Ids.ensureId(initial${meta.data.dataServiceIdName}))
+    const ${meta.data.dataServiceIdName} = this.${meta.data.dataServiceName}[this.${meta.data.dataServiceName}.length - 1]
+    ${relations
+        .map((r) => `
+        ${r.isRequired
+        ? `
+            if (${meta.data.dataServiceIdName}.${r.name}) {
+                if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === ${meta.data.dataServiceIdName}.${r.name}) === -1 ) {
+                    this.add${r.model.typeName}({ id: ${meta.data.dataServiceIdName}.${r.name} })
+                }
+            } else {
+                if (this.${r.meta.data.dataServiceName}.length === 0) {
+                  this.add${r.model.typeName}()
+                }
+                ${meta.data.dataServiceIdName}.${r.name} = this.${r.meta.data.dataServiceName}[0].id
+              }
+        `
+        : `
+            if (${meta.data.dataServiceIdName}.${r.name}) {
+              if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === ${meta.data.dataServiceIdName}.${r.name}) === -1 ) {
+                  this.add${r.model.typeName}({ id: ${meta.data.dataServiceIdName}.${r.name} })
+              }
+            }
+            `}
+    `)
+        .join('\n')}
+    return this
+  }`;
+}

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

@@ -7,3 +7,10 @@ export declare function generateStubsIndex({ models, meta }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;
+/**
+ * Generates an index file that exports all stubs for the data mocker.
+ */
+export declare function generateDataMockerStubsIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStubsIndex = void 0;
+exports.generateDataMockerStubsIndex = exports.generateStubsIndex = void 0;
 const exports_1 = require("../../lib/exports");
 const meta_1 = require("../../lib/meta");
 /**
@@ -15,3 +15,15 @@ function generateStubsIndex({ models, meta }) {
     return exports.generate();
 }
 exports.generateStubsIndex = generateStubsIndex;
+/**
+ * Generates an index file that exports all stubs for the data mocker.
+ */
+function generateDataMockerStubsIndex({ models, meta }) {
+    const exports = exports_1.ExportsGenerator.from(meta.data.dataMockerStubIndexFilePath);
+    for (const model of models) {
+        const meta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(meta.data.dataMockerStubFilePath);
+    }
+    return exports.generate();
+}
+exports.generateDataMockerStubsIndex = generateDataMockerStubsIndex;

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

@@ -9,12 +9,17 @@ const types_1 = require("../../lib/types");
  * Generates a stub definition file for a given model.
  */
 function generateStub({ model, meta }) {
-    const { fields } = model;
+    const { fields, idField } = model;
     const imports = imports_1.ImportsGenerator.from(meta.data.stubFilePath).addImport({
         items: [model.typeName, meta.types.toBrandedIdTypeFnName],
         from: meta.types.importPath,
     });
-    const assignments = getAssignmentStatementModel({ fields, imports });
+    const assignments = getAssignmentStatementModel({
+        fields,
+        nameField: model.nameField,
+        modelName: model.name,
+        imports,
+    });
     return `
 ${imports.generate()}
 
@@ -29,10 +34,11 @@ export const ${meta.data.defaultStubConstantName}: ${model.typeName} = {
  * Utility function that creates a new ${meta.userFriendlyName} object from a partial object of values.
  */
 export const ${meta.data.stubGenerationFnName} = (
-	item: Partial<${model.typeName}>
+	item: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName}}>
 ): ${model.typeName} => ({
   ...${meta.data.defaultStubConstantName},
   ...item,
+  ${idField.name}: item.${idField.name} ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : ${meta.data.defaultStubConstantName}.id,
 })
 `;
 }
@@ -40,7 +46,7 @@ exports.generateStub = generateStub;
 /**
  * Return an assignment statement for a model where each field is assigned null or its type's default value.
  */
-function getAssignmentStatementModel({ fields, imports }) {
+function getAssignmentStatementModel({ fields, nameField, modelName, imports, }) {
     return fields
         .map((f) => {
         if (!f.isRequired) {
@@ -48,6 +54,9 @@ function getAssignmentStatementModel({ fields, imports }) {
         }
         switch (f.kind) {
             case 'scalar': {
+                if ((nameField === null || nameField === void 0 ? void 0 : nameField.name) === f.name) {
+                    return `${f.name}: '${modelName}'`;
+                }
                 return `${f.name}: ${(0, fields_1.getDefaultValueForType)(f.tsTypeName)}`;
             }
             case 'id': {

package/dist/lib/meta.d.ts

@@ -25,6 +25,18 @@ export type SchemaMetaData = {
          * Path to the file containing data service class definitions.
          */
         dataServiceFilePath: Types.Path;
+        /**
+         * Path to the file containing data mocker class definitions.
+         */
+        dataMockerFilePath: Types.Path;
+        /**
+         * Path to the file containing data mocker class definitions.
+         */
+        dataMockerStubIndexFilePath: Types.Path;
+        /**
+         * Path that may be used to import the data mocker stubs.
+         */
+        dataMockerStubImportPath: Types.Path;
         /**
          * Path to the file containing test data service definition.
          */
@@ -178,6 +190,10 @@ export type ModelMetaData = {
          * The path to the file containing stub definitions of this model.
          */
         stubFilePath: Types.Path;
+        /**
+         * The path to the file containing stub definitions for the data mocker of this model.
+         */
+        dataMockerStubFilePath: Types.Path;
         /**
          * The name of the TypeScript constant that contains default values for all fields.
          */
@@ -214,6 +230,10 @@ export type ModelMetaData = {
          * The name by which the repository is exposed in the dataService/context. (e.g. aggregations)
          */
         dataServiceName: Types.VariableName;
+        /**
+         * The name for internal use of modelIds in data mocker
+         */
+        dataServiceIdName: Types.VariableName;
         /**
          * The name of the export Excel table (e.g. `Aggregations`).
          */

package/dist/lib/meta.js

@@ -38,6 +38,9 @@ function getSchemaMetadata({ config }) {
             dataMockModuleFilePath: Types.toPath(`${config.paths.dataLibPath}data.mock.module`),
             testDataServiceFilePath: Types.toPath(`${config.paths.dataLibPath}test-data.service`),
             dataServiceFilePath: Types.toPath(`${config.paths.dataLibPath}data.service`),
+            dataMockerFilePath: Types.toPath(`${config.paths.cypressPath}support/data-mocker.class`),
+            dataMockerStubImportPath: Types.toPath(`${config.paths.cypressPath}support/stubs`),
+            dataMockerStubIndexFilePath: Types.toPath(`${config.paths.cypressPath}support/stubs/index`),
             repositoriesConstFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/repositories`),
             repositoriesIndexFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/index`),
             stubIndexFilePath: Types.toPath(`${config.paths.dataLibPath}stubs/index`),
@@ -77,7 +80,7 @@ exports.getSchemaMetadata = getSchemaMetadata;
  */
 function getModelMetadata({ model }) {
     const { name, schemaConfig: config } = model;
-    const { PascalCase, camelCase, pluralized, uncapitalizedPlural, capitalizedPlural } = (0, string_1.conjugateNames)(name);
+    const { PascalCase, camelCase, pluralized, uncapitalizedPlural, uncapitalized, capitalizedPlural } = (0, string_1.conjugateNames)(name);
     return {
         userFriendlyName: PascalCase,
         internalSingularName: Types.toVariableName(camelCase),
@@ -90,11 +93,13 @@ function getModelMetadata({ model }) {
             mockRepoFileName: Types.toFileName(`${camelCase}.mock.repository`),
             mockRepoFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/mock/${camelCase}.mock.repository`),
             stubFilePath: Types.toPath(`${config.paths.dataLibPath}stubs/${camelCase}.stub`),
+            dataMockerStubFilePath: Types.toPath(`${config.paths.cypressPath}support/stubs/${camelCase}.stub`),
             importPath: Types.toPath(`@${config.project}/data`),
             stubGenerationFnName: Types.toFunction(`stub${PascalCase}`),
             repositoryClassName: Types.toClassName(`${PascalCase}Repository`),
             mockRepositoryClassName: Types.toClassName(`Mock${PascalCase}Repository`),
             dataServiceName: Types.toVariableName(`${uncapitalizedPlural}`),
+            dataServiceIdName: Types.toVariableName(`${uncapitalized}`),
             excelExportTableName: `${pluralized}`,
             repository: {
                 decoderFnName: Types.toFunction(`to${PascalCase}`),

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

@@ -55,6 +55,10 @@ export type SchemaConfig = {
          * may reference data library using `@project/data` import.
          */
         dataLibPath: Types.Path;
+        /**
+         * Path to the directory containing Cypress project.
+         */
+        cypressPath: Types.Path;
         /**
          * Path to the directory containing business logic.
          *

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

@@ -30,5 +30,6 @@ export declare const conjugateNames: (name: string) => {
     camelCase: string;
     pluralized: string;
     uncapitalizedPlural: string;
+    uncapitalized: string;
     capitalizedPlural: string;
 };

package/dist/lib/utils/string.js

@@ -111,6 +111,7 @@ const conjugateNames = (name) => ({
     camelCase: (0, exports.toCamelCase)(name),
     pluralized: (0, exports.capitalize)((0, exports.pluralize)(name)),
     uncapitalizedPlural: (0, exports.uncapitalize)((0, exports.pluralize)(name)),
+    uncapitalized: (0, exports.uncapitalize)(name),
     capitalizedPlural: (0, exports.capitalize)((0, exports.pluralize)(name)),
 });
 exports.conjugateNames = conjugateNames;

package/dist/prisma/parse.js

@@ -82,6 +82,9 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         if (!referencedModel) {
             (0, error_1.throwError)(`Investigate: Field references unknown model ${dmmfField.type}.`);
         }
+        if (dmmfField.relationOnDelete && dmmfField.relationOnDelete !== 'NoAction') {
+            (0, error_1.throwError)(`Investigate: "onDelete" attribute for relationship ${dmmfField.relationName} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
+        }
         relations[dmmfField.relationFromFields[0]] = referencedModel;
     }
     const relationFields = dmmfModel.fields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -22,7 +22,7 @@
     "prettier": "^2.8.8",
     "remeda": "1.9.4",
     "zod": "3.21.4",
-    "@postxl/lock": "0.4.8"
+    "@postxl/lock": "0.4.9"
   },
   "devDependencies": {
     "@prisma/client": "^5.2.0",
@@ -46,7 +46,7 @@
     "build": "tsc -p tsconfig.build.json",
     "prepublish": "tsc -p tsconfig.build.json",
     "dev": "tsc -p tsconfig.build.json -w",
-    "test:generation": "./scripts/test.sh",
+    "test:generators": "./scripts/test.sh",
     "test:jest": "jest",
     "test:watch": "jest --watch",
     "test:types": "tsc --noEmit"