@postxl/generator 0.54.0 → 0.56.0

package/dist/prisma/parse.js

@@ -136,34 +136,43 @@ function parseModel({ dmmfModel, enums, models, config, }) {
     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
-    // relations and then figure out which scalar fields are used in relations.
-    const relations = {};
+    // 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 as a foreign key.
+    //
+    //       Since Prisma doesn't mark foreign-key fields as relations,
+    //       we need to preprocess relations and then figure out which scalar
+    //       fields are actually foreign-keys.
+    const referencedModels = {};
+    /**
+     * A map of models that are referenced in any way in the relations.
+     */
+    const relatedModels = {};
     for (const dmmfField of dmmfModel.fields) {
-        if (dmmfField.kind !== 'object' ||
-            !dmmfField.relationName ||
-            !dmmfField.relationFromFields ||
-            !dmmfField.relationToFields) {
+        if (dmmfField.kind !== 'object' || !dmmfField.relationName) {
             continue;
         }
-        if (dmmfField.relationFromFields.length > 1) {
-            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
-        }
         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)}.`);
         }
+        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.
+            relatedModels[dmmfField.type] = referencedModel;
+            continue;
+        }
+        if (dmmfField.relationFromFields.length > 1) {
+            (0, error_1.throwError)(`Field ${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!`);
         }
         // 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.
-        relations[dmmfField.relationFromFields[0]] = referencedModel;
+        referencedModels[dmmfField.relationFromFields[0]] = referencedModel;
     }
     const relationFields = dmmfModel.fields
-        .filter((f) => f.kind === 'object' && f.relationToFields && f.relationToFields.length === 1)
+        .filter((f) => { var _a; return f.kind === 'object' && ((_a = f.relationToFields) === null || _a === void 0 ? void 0 : _a.length) === 1; })
         .reduce((acc, f) => {
         if (f.relationFromFields && f.relationFromFields[0]) {
             acc[f.relationFromFields[0]] = f;
@@ -171,9 +180,14 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         return acc;
     }, {});
     const fields = dmmfModel.fields
-        .filter((dmmfField) => 
-    // if field is a "backlink", i.e. the receiver of a relation, we ignore it
-    dmmfField.kind !== 'object')
+        .filter((dmmfField) => {
+        // NOTE: This is a relation field that we'll handle when we process its foreign-key. If it's a back relation
+        //       then it won't have a foreign-key and we simply ignore it.
+        if (dmmfField.kind === 'object') {
+            return false;
+        }
+        return true;
+    })
         .map((dmmfField) => {
         const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
         const fieldName = highlight(`${dmmfModel.name}.${dmmfField.name}`);
@@ -187,17 +201,19 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             schemaType: dmmfField.type,
         };
         // NOTE: We mark scalar fields which are used in relations as relation fields by Purple Schema standards.
-        if (dmmfField.name in relations) {
-            const refModel = relations[dmmfField.name];
+        if (dmmfField.name in referencedModels) {
+            const refModel = referencedModels[dmmfField.name];
             const refField = relationFields[dmmfField.name];
             if (!refField) {
                 (0, error_1.throwError)(`${fieldName}: Relation field ${highlight(dmmfField.name)} not found.`);
             }
-            return Object.assign(Object.assign({ kind: 'relation' }, shared), { relatedModelBacklinkFieldName: Types.toFieldName(refField.name), typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
+            const _field = Object.assign(Object.assign({ kind: 'relation' }, shared), { relationFieldName: Types.toFieldName(refField.name), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
+            return _field;
         }
         if (dmmfField.isId) {
             const isGeneratedField = isAutoIncrementField(dmmfField) || isUUIDField(dmmfField);
-            return Object.assign(Object.assign({ kind: 'id' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
+            const _field = Object.assign(Object.assign({ kind: 'id' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
+            return _field;
         }
         if (dmmfField.kind === 'scalar') {
             let validation = undefined;
@@ -210,14 +226,16 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             if (dmmfField.type === 'Float') {
                 validation = { type: 'float' };
             }
-            return Object.assign(Object.assign({ kind: 'scalar', validation }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), tsTypeName: getTsTypeForScalar(dmmfField) });
+            const _field = Object.assign(Object.assign({ kind: 'scalar', validation }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), tsTypeName: getTsTypeForScalar(dmmfField) });
+            return _field;
         }
         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)}.`);
             }
-            return Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
+            const _field = Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
+            return _field;
         }
         (0, error_1.throwError)(`${fieldName} is not scalar, enum nor relation.`);
     })
@@ -228,7 +246,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         nameField,
         fields,
         createdAtField,
-        updatedAtField });
+        updatedAtField, relatedModels: Object.values(relatedModels) });
 }
 /**
  * Checks that there is exactly one id field and that there is at most one default field.
@@ -290,7 +308,13 @@ function validateFields({ fields, model: { name } }) {
     if (!idField) {
         (0, error_1.throwError)(`Model ${highlight(name)} does not have an id field`);
     }
-    return { idField, defaultField, nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField, createdAtField, updatedAtField };
+    return {
+        idField,
+        defaultField,
+        nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField,
+        createdAtField,
+        updatedAtField,
+    };
 }
 function isAutoIncrementField(fieldDmmf) {
     if (fieldDmmf.default === undefined) {

package/package.json

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