@postxl/generator 0.63.0 → 0.63.2

package/dist/generators/indices/importexport-types.generator.js

@@ -46,9 +46,12 @@ function generateImportExportTypes({ models, meta }) {
         `);
             }
             if (field.kind === 'scalar' && field.isUnique) {
-                nonUniqueFieldErrors.push(`
-          ${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName}>
-        `);
+                if (field.isRequired) {
+                    nonUniqueFieldErrors.push(`${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName}>`);
+                }
+                else {
+                    nonUniqueFieldErrors.push(`${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName} | null>`);
+                }
             }
             if (field.kind === 'scalar' && field.validation) {
                 invalidTypeFieldErrors.push(`

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

@@ -1166,11 +1166,13 @@ function generateUniqueFieldsBlocks({ model }) {
         removeCode: [],
     };
     for (const f of fields) {
+        const returnType = `string${f.isRequired ? '' : ' | null'}`;
         result.mapDeclarations.push(`'${f.name}': new Map<string, ${model.typeName}>()`);
         result.getByFunctions.push(`
       // NOTE: The current implementation is synchronous, but it needs to be async to conform to the interface.
       // eslint-disable-next-line @typescript-eslint/require-await
-      public async getBy${(0, string_1.toPascalCase)(f.name)}(${f.name}: string): Promise<${model.typeName} | undefined> { 
+      public async getBy${(0, string_1.toPascalCase)(f.name)}(${f.name}: ${returnType}): Promise<${model.typeName} | undefined> {
+        ${f.isRequired ? '' : `if (${f.name} === null) { return undefined }`}
         return this.uniqueIds.${f.name}.get(${(0, string_1.toCamelCase)(f.name)})
       }`);
         result.clearCode.push(`this.uniqueIds.${f.name}.clear()`);
@@ -1183,7 +1185,7 @@ function generateUniqueFieldsBlocks({ model }) {
       /**
        * Utility function that ensures that the ${f.name} field is unique
        */      
-      private ${getEnsureUniqueFnName(f)}(item: { ${f.name}?: string }) {
+      private ${getEnsureUniqueFnName(f)}(item: { ${f.name}?: ${returnType} }) {
           if (!item.${f.name}) {
             return
           }
@@ -1202,8 +1204,14 @@ function generateUniqueFieldsBlocks({ model }) {
           this.logger.log(\`${model.typeName} ${f.name} "\${item.${f.name}}" already exists. Renaming to "\${${f.name}}")\`)
           item.${f.name} = ${f.name}
         }`);
-        result.setCode.push(`this.uniqueIds.${f.name}.set(item.${f.name}, item)`);
-        result.removeCode.push(`this.uniqueIds.${f.name}.delete(item.${f.name})`);
+        if (f.isRequired) {
+            result.setCode.push(`this.uniqueIds.${f.name}.set(item.${f.name}, item)`);
+            result.removeCode.push(`this.uniqueIds.${f.name}.delete(item.${f.name})`);
+        }
+        else {
+            result.setCode.push(`if (item.${f.name} !== null) { this.uniqueIds.${f.name}.set(item.${f.name}, item) }`);
+            result.removeCode.push(`if (item.${f.name} !== null) { this.uniqueIds.${f.name}.delete(item.${f.name}) }`);
+        }
     }
     if (fields.length > 1) {
         result.verifyFunctionComment = `In case a value of the fields ${fields

package/dist/lib/attributes.d.ts

@@ -15,7 +15,7 @@ export type ModelAttributes = {
      * @internal
      * Note: Prisma has it's own schema attribute - but does not expose it in the DMMF.
      */
-    databaseSchema?: string;
+    databaseSchema: string;
     /**
      * Schema tag: ´@@InMemoryOnly()`
      * Whether the model should be stored in the database or only in memory.

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

@@ -1,3 +1,4 @@
+import z from 'zod';
 /**
  * Prisma generator often overwrites any error message because of some concurrency issues.
  * By showing the error via console.log and throwing it again, we ensure that the error message is shown.
@@ -7,3 +8,10 @@ export declare function throwError(message: string): never;
  * Extracts the error message from an error object or any other object.
  */
 export declare function extractError(error: unknown): string;
+/**
+ * Tries to extract and format a Zod error to a nice log string, color highlighting
+ * the object properties that failed validation and their respective error messages.
+ *
+ * As a fallback, it returns a JSON string representation of the error.
+ */
+export declare function formatZodError(e: z.ZodError): string;

package/dist/lib/utils/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractError = exports.throwError = void 0;
+exports.formatZodError = exports.extractError = exports.throwError = void 0;
 /**
  * Prisma generator often overwrites any error message because of some concurrency issues.
  * By showing the error via console.log and throwing it again, we ensure that the error message is shown.
@@ -21,3 +21,33 @@ function extractError(error) {
     return JSON.stringify(error);
 }
 exports.extractError = extractError;
+function extractNestedErrors(value) {
+    if (!value._errors) {
+        return '';
+    }
+    return value._errors.join(' or ');
+}
+/**
+ * Tries to extract and format a Zod error to a nice log string, color highlighting
+ * the object properties that failed validation and their respective error messages.
+ *
+ * As a fallback, it returns a JSON string representation of the error.
+ */
+function formatZodError(e) {
+    console.log(e);
+    const formatted = e.format();
+    if (typeof formatted === 'string') {
+        return formatted;
+    }
+    if (typeof formatted !== 'object') {
+        return JSON.stringify(e.format(), null, 2);
+    }
+    if (formatted._errors && formatted._errors.length > 0) {
+        return `\t${formatted._errors.join(' or ')}`;
+    }
+    return Object.entries(formatted)
+        .filter(([key]) => key !== '_errors')
+        .map(([key, value]) => `\t${key}:\t ${extractNestedErrors(value)}`)
+        .join('\n');
+}
+exports.formatZodError = formatZodError;

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

@@ -9,3 +9,9 @@ export interface Logger {
     error(message: unknown, ...optionalParams: unknown[]): void;
     query(message: unknown, ...optionalParams: unknown[]): void;
 }
+/**
+ * Highlights a string cyan
+ *
+ * NOTE: We would normally use `chalk.cyan` here, but this causes an error in the Prisma generator, so we use this workaround.
+ */
+export declare function highlight(str: string): string;

package/dist/lib/utils/logger.js

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.highlight = void 0;
+/**
+ * Highlights a string cyan
+ *
+ * NOTE: We would normally use `chalk.cyan` here, but this causes an error in the Prisma generator, so we use this workaround.
+ */
+function highlight(str) {
+    return `\u001B[36m${str}\u001B[39m`;
+}
+exports.highlight = highlight;

package/dist/prisma/attributes.js

@@ -5,6 +5,8 @@ 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 zod_1 = __importDefault(require("zod"));
+const error_1 = require("../lib/utils/error");
+const logger_1 = require("../lib/utils/logger");
 const string_1 = require("../lib/utils/string");
 /**
  * Parses attributes from a given string using provided prefix.
@@ -71,7 +73,9 @@ function getModelAttributes(model) {
         ignore: blankStringBooleanDecoder,
         inMemoryOnly: blankStringBooleanDecoder,
         description: zod_1.default.string().optional(),
-        schema: zod_1.default.string().optional(),
+        schema: zod_1.default.string({
+            required_error: `The PostXL attribute ${(0, logger_1.highlight)('`///@@Schema`')} attribute must be provided (in addition to Prisma's @@schema attribute)!`,
+        }),
         index: zod_1.default.array(zod_1.default.string()).optional(),
         seed: zod_1.default.string().optional(),
         systemUser: zod_1.default
@@ -90,7 +94,7 @@ function getModelAttributes(model) {
     }));
     const result = decoder.safeParse(attributes);
     if (!result.success) {
-        throw new Error(`Model ${model.name} has invalid model attributes: ${result.error.toString()}`);
+        throw new Error((0, error_1.formatZodError)(result.error));
     }
     return result.data;
 }

package/dist/prisma/parse.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePrismaSchema = void 0;
 const Types = __importStar(require("../lib/schema/types"));
 const error_1 = require("../lib/utils/error");
+const logger_1 = require("../lib/utils/logger");
 const string_1 = require("../lib/utils/string");
 const attributes_1 = require("./attributes");
 /**
@@ -54,7 +55,7 @@ function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw },
             const referencedModel = modelsWithFields.find((m) => m.sourceName === field.relationToModel.sourceName);
             if (!referencedModel) {
                 // NOTE: This should never happen because Prisma should validate the validity of the relation.
-                (0, error_1.throwError)(`Model ${highlight(mwf.name)} not found!`);
+                (0, error_1.throwError)(`Model ${(0, logger_1.highlight)(mwf.name)} not found!`);
             }
             referencedModel.references.push({
                 referencingModel: mwf,
@@ -68,7 +69,7 @@ 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 ${highlight(requiredModel)} not found in schema!`);
+            (0, error_1.throwError)(`Required model ${(0, logger_1.highlight)(requiredModel)} not found in schema!`);
         }
     }
 }
@@ -89,13 +90,13 @@ function ensureConsistency({ models, enums }) {
     }
     for (const model of models) {
         if ((0, string_1.isPlural)(model.name)) {
-            errors.push(`Model ${highlight(model.name)} is plural. Please use singular names for models.`);
+            errors.push(`Model ${(0, logger_1.highlight)(model.name)} is plural. Please use singular names for models.`);
         }
         try {
             (0, attributes_1.getModelAttributes)(model);
         }
         catch (e) {
-            errors.push(`Model ${highlight(model.name)} has invalid model attributes: ${(0, error_1.extractError)(e)}`);
+            errors.push(`Model ${(0, logger_1.highlight)(model.name)} has invalid model attributes: ${(0, error_1.extractError)(e)}`);
         }
     }
     for (const model of models) {
@@ -104,7 +105,7 @@ function ensureConsistency({ models, enums }) {
                 (0, attributes_1.getFieldAttributes)(field);
             }
             catch (e) {
-                errors.push(`Model ${highlight(model.name)} has invalid attributes for field ${highlight(field.name)}: 
+                errors.push(`Model ${(0, logger_1.highlight)(model.name)} has invalid attributes for field ${(0, logger_1.highlight)(field.name)}: 
             ${(0, error_1.extractError)(e)}`);
             }
         }
@@ -114,7 +115,7 @@ function ensureConsistency({ models, enums }) {
             (0, attributes_1.getEnumAttributes)(enumDef);
         }
         catch (e) {
-            errors.push(`Enum ${highlight(enumDef.name)} has invalid attributes: 
+            errors.push(`Enum ${(0, logger_1.highlight)(enumDef.name)} has invalid attributes: 
         ${(0, error_1.extractError)(e)}`);
         }
     }
@@ -168,17 +169,17 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         }
         const referencedModel = models.find((m) => m.sourceName === dmmfField.type);
         if (!referencedModel) {
-            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.name}`)} references unknown model ${highlight(dmmfField.type)}.`);
+            (0, error_1.throwError)(`Field ${(0, logger_1.highlight)(`${dmmfModel.name}.${dmmfField.name}`)} references unknown model ${(0, logger_1.highlight)(dmmfField.type)}.`);
         }
         if (!dmmfField.relationFromFields || dmmfField.relationFromFields.length === 0) {
             // NOTE: This field has no foreign-key values in this model so it must be a back-relation.
             continue;
         }
         if (dmmfField.relationFromFields.length > 1) {
-            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
+            (0, error_1.throwError)(`Field ${(0, logger_1.highlight)(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
         }
         if (dmmfField.relationOnDelete && dmmfField.relationOnDelete !== 'NoAction') {
-            (0, error_1.throwError)(`Investigate model ${highlight(dmmfModel.name)}: "onDelete" attribute for relationship ${highlight(dmmfField.relationName)} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
+            (0, error_1.throwError)(`Investigate model ${(0, logger_1.highlight)(dmmfModel.name)}: "onDelete" attribute for relationship ${(0, logger_1.highlight)(dmmfField.relationName)} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
         }
         // NOTE: At this point, we only have the `ModelCore`. After all models are parsed, we need to updated
         //       the relations with the full `Model`. This is done in the `linkModels` function.
@@ -202,7 +203,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
     })
         .map((dmmfField) => {
         const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
-        const fieldName = highlight(`${dmmfModel.name}.${dmmfField.name}`);
+        const fieldName = (0, logger_1.highlight)(`${dmmfModel.name}.${dmmfField.name}`);
         const shared = {
             name: Types.toFieldName((0, string_1.toCamelCase)(dmmfField.name)),
             description: attributes.description,
@@ -217,7 +218,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             const refModel = referencedModels[dmmfField.name];
             const refField = relationFields[dmmfField.name];
             if (!refField) {
-                (0, error_1.throwError)(`${fieldName}: Relation field ${highlight(dmmfField.name)} not found.`);
+                (0, error_1.throwError)(`${fieldName}: Relation field ${(0, logger_1.highlight)(dmmfField.name)} not found.`);
             }
             const _field = Object.assign(Object.assign({ kind: 'relation' }, shared), { relationFieldName: Types.toFieldName(refField.name), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
             return _field;
@@ -244,7 +245,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         if (dmmfField.kind === 'enum') {
             const fieldEnumDef = enums.find((e) => e.sourceName === dmmfField.type);
             if (!fieldEnumDef) {
-                (0, error_1.throwError)(`${fieldName}: Field references unknown enum ${highlight(dmmfField.type)}.`);
+                (0, error_1.throwError)(`${fieldName}: Field references unknown enum ${(0, logger_1.highlight)(dmmfField.type)}.`);
             }
             const _field = Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
             return _field;
@@ -274,7 +275,7 @@ function validateFields({ fields, model: { name } }) {
     let nameField = undefined;
     let defaultField = undefined;
     for (const field of fields) {
-        const fieldName = highlight(`${name}.${field.name}`);
+        const fieldName = (0, logger_1.highlight)(`${name}.${field.name}`);
         switch (field.kind) {
             case 'scalar':
                 if (field.name === 'name') {
@@ -320,7 +321,7 @@ function validateFields({ fields, model: { name } }) {
         }
     }
     if (!idField) {
-        (0, error_1.throwError)(`Model ${highlight(name)} does not have an id field`);
+        (0, error_1.throwError)(`Model ${(0, logger_1.highlight)(name)} does not have an id field`);
     }
     return {
         idField,
@@ -402,12 +403,12 @@ function getTsTypeForScalar(field) {
             return Types.toTypeName('number');
         case 'Json':
         case 'Bytes':
-            (0, error_1.throwError)(`Field ${highlight(field.name)}: Type ${field.type} Not implemented yet`);
+            (0, error_1.throwError)(`Field ${(0, logger_1.highlight)(field.name)}: Type ${field.type} Not implemented yet`);
         // 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:
-            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${highlight(field.name)} of type ${field.type}`);
+            (0, error_1.throwError)(`Investigate: 'default' case in getTsTypeForScalar for field ${(0, logger_1.highlight)(field.name)} of type ${field.type}`);
     }
 }
 /**
@@ -425,7 +426,7 @@ function getTsTypeForId(field) {
         case 'Int':
             return Types.toTypeName('number');
         default:
-            (0, error_1.throwError)(`The id field ${highlight(field.name)} is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
+            (0, error_1.throwError)(`The id field ${(0, logger_1.highlight)(field.name)} is of type ${field.type} - but only BigInt, Boolean, Decimal, Float, Int and String are supported for Ids.`);
     }
 }
 /**
@@ -440,17 +441,9 @@ function getTsTypeForEnum(field) {
         case 'Decimal':
         case 'Float':
         case 'Int':
-            (0, error_1.throwError)(`The enum field ${highlight(field.name)} is of type ${field.type} - but only String fields are supported for enums so far.`);
+            (0, error_1.throwError)(`The enum field ${(0, logger_1.highlight)(field.name)} is of type ${field.type} - but only String fields are supported for enums so far.`);
             break;
         default:
             return Types.toTypeName(field.type);
     }
 }
-/**
- * Highlights a string cyan
- *
- * NOTE: We would normally use `chalk.cyan` here, but this causes an error in the generator, so we use this workaround.
- */
-function highlight(str) {
-    return `\u001B[36m${str}\u001B[39m`;
-}

package/package.json

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