@postxl/generator 0.15.1 → 0.15.2

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

@@ -23,93 +23,102 @@ function generateSeedModel({ model, itemCount, meta, }) {
             from: depMeta.types.importPath,
         });
     }
-    const exampleMode = getExampleMode({ model, maxItemCount: itemCount });
-    const seed = [];
-    for (let i = 1; i <= exampleMode.itemCount; i++) {
-        seed.push(generateSeedData({ model, index: i, exampleMode }));
+    const mode = getExampleMode({ model, maxItemCount: itemCount });
+    const examples = [];
+    for (let i = 1; i <= mode.itemCount; i++) {
+        examples.push(generateExample({ model, index: i, mode }));
     }
     return `
     ${imports.generate()}
 
     export const ${meta.seed.constantName}: ${model.typeName}[] = [
-      ${seed.join(',\n')}
+      ${examples.join(',\n')}
     ]
   `;
 }
 exports.generateSeedModel = generateSeedModel;
 /**
- * In case of a model with examples, there are two options:
- * 1. the number of examples per field is the same for all fields with examples -> we generate them as tuples
- * 2. the number of examples per field is different -> we generate them as random permutations
- * Here we determine which option to use - and the number of tuples/permutations available
+ * Returns the mode of examples and the number of examples per field for a given model.
  */
 function getExampleMode({ model, maxItemCount }) {
     let numberOfExamplesPerField = undefined;
     let sameNumberOfExamplesPerField = true;
-    let examplePermutations = 0;
+    let numberOfAllPossiblePermutations = 0;
     for (const field of model.fields) {
-        if (field.kind === 'scalar' && field.attributes.examples && field.attributes.examples.length > 0) {
+        if ((field.kind === 'scalar' || field.kind === 'relation' || field.kind == 'id') &&
+            field.attributes.examples &&
+            field.attributes.examples.length > 0) {
             if (numberOfExamplesPerField === undefined) {
                 numberOfExamplesPerField = field.attributes.examples.length;
-                examplePermutations = 1;
+                numberOfAllPossiblePermutations = 1;
             }
             else if (numberOfExamplesPerField !== field.attributes.examples.length) {
                 sameNumberOfExamplesPerField = false;
             }
-            examplePermutations *= field.attributes.examples.length;
+            numberOfAllPossiblePermutations *= field.attributes.examples.length;
         }
     }
     if (numberOfExamplesPerField === undefined) {
-        return { mode: 'NoExamples', itemCount: maxItemCount };
+        return { kind: 'Random', itemCount: maxItemCount };
     }
-    else if (sameNumberOfExamplesPerField) {
-        return {
-            mode: 'Tuples',
-            itemCount: numberOfExamplesPerField,
-        };
-    }
-    else {
-        return { mode: 'Permutations', itemCount: examplePermutations < maxItemCount ? examplePermutations : maxItemCount };
+    if (sameNumberOfExamplesPerField) {
+        return { kind: 'Tuples', itemCount: numberOfExamplesPerField };
     }
+    return { kind: 'Permutations', itemCount: Math.min(numberOfAllPossiblePermutations, maxItemCount) };
 }
-function generateSeedData({ model, index, exampleMode, }) {
+function generateExample({ model, index, mode }) {
     const data = new serializer_1.Serializer();
     data.append('{');
     for (const field of model.fields.values()) {
-        data.append(`${field.name}: ${generateFieldData({ field, model, index, exampleMode })},`);
+        data.append(`${field.name}: ${generateFieldData({ field, model, index, mode })},`);
     }
     data.append('}');
     return data.print();
 }
-function generateFieldData({ field, model, index, exampleMode, }) {
+function generateFieldData({ field, model, index, mode, }) {
     switch (field.kind) {
         case 'id':
-            return generateFieldDataId({ field, model, index });
+            return generateIdFieldExample({ field, model, index, mode });
         case 'scalar':
-            return generateFieldDataScalar({ field, model, index, exampleMode });
+            return generateScalarFieldExample({ field, model, index, mode });
         case 'relation':
-            return generateFieldDataRelation({ field, model, index, itemCount: exampleMode.itemCount });
+            return generateRelationFieldExample({ field, model, index, mode });
         case 'enum':
-            return generateFieldDataEnum({ field, exampleMode, index });
+            return generateEnumFieldExample({ field, mode, index });
         default:
             throw new types_1.ExhaustiveSwitchCheck(field);
     }
 }
-function generateFieldDataId({ field, index }) {
+function generateIdFieldExample({ field, model, index, mode, }) {
     const idModelMeta = (0, meta_1.getModelMetadata)({ model: field.model });
-    return `${idModelMeta.types.toBrandedIdTypeFnName}(${field.unbrandedTypeName === 'string' ? `'${index}'` : index})`;
+    const { hasExample, example } = generateFieldExample({ field, model, index, mode });
+    if (field.unbrandedTypeName === 'string') {
+        if (hasExample && typeof example === 'string' && index <= mode.itemCount) {
+            return `${idModelMeta.types.toBrandedIdTypeFnName}('${quoteSingleQuote(example)}')`;
+        }
+        return `${idModelMeta.types.toBrandedIdTypeFnName}('${index}')`;
+    }
+    else if (field.unbrandedTypeName === 'number') {
+        if (hasExample && typeof example === 'number') {
+            return `${idModelMeta.types.toBrandedIdTypeFnName}(${example})`;
+        }
+        return `${idModelMeta.types.toBrandedIdTypeFnName}(${index})`;
+    }
+    else {
+        throw new Error(`Unsupported id type for ${model.name}.${field.name}: ${field.unbrandedTypeName}`);
+    }
 }
 function quoteSingleQuote(str) {
     return str.replace(/'/g, "\\'");
 }
-function generateFieldDataScalar({ field, model, index, exampleMode, }) {
-    const { hasExample, example } = getFieldExample({ field, model, index, exampleMode });
+function generateScalarFieldExample({ field, model, index, mode, }) {
+    const { hasExample, example } = generateFieldExample({ field, model, index, mode });
     switch (field.typeName) {
         case 'string': {
             if (hasExample && typeof example === 'string') {
                 return `'${quoteSingleQuote(example)}'`;
             }
-            const result = generateFieldDataString({ field, model, index });
+            const result = generateMockString({ field, model, index });
             if (result === null) {
                 return 'null';
             }
@@ -122,20 +131,20 @@ function generateFieldDataScalar({ field, model, index, exampleMode, }) {
             if (hasExample) {
                 return `${example}`;
             }
-            return generateFieldDataNumber();
+            return generateMockNumber();
         }
         case 'boolean': {
             if (hasExample) {
                 return `${example}`;
             }
-            return generateFieldDataBoolean();
+            return generateMockBoolean();
         }
         case 'Date': {
             if (hasExample) {
                 // TODO: Maybe we should parse the date example to correct format?
                 return `${example}`;
             }
-            return generateFieldDataDate();
+            return generateMockDate();
         }
         default: {
             console.warn(`Unknown scalar type: ${field.typeName}`);
@@ -143,14 +152,14 @@ function generateFieldDataScalar({ field, model, index, exampleMode, }) {
         }
     }
 }
-function getFieldExample({ field, index, exampleMode, }) {
-    if (exampleMode.mode === 'NoExamples') {
+function generateFieldExample({ field, index, mode, }) {
+    if (mode.kind === 'Random') {
         return { hasExample: false };
     }
     if (!field.attributes.examples || field.attributes.examples.length === 0) {
         return { hasExample: false };
     }
-    switch (exampleMode.mode) {
+    switch (mode.kind) {
         case 'Permutations': {
             const example = faker_1.faker.helpers.arrayElement(field.attributes.examples);
             return { hasExample: true, example };
@@ -160,11 +169,11 @@ function getFieldExample({ field, index, exampleMode, }) {
             return { hasExample: true, example };
         }
         default: {
-            throw new types_1.ExhaustiveSwitchCheck(exampleMode);
+            throw new types_1.ExhaustiveSwitchCheck(mode);
         }
     }
 }
-function generateFieldDataString({ field, model, index }) {
+function generateMockString({ field, model, index }) {
     if (field.name === 'name') {
         return `${(0, string_1.toPascalCase)(model.name)} ${index}`;
     }
@@ -173,26 +182,39 @@ function generateFieldDataString({ field, model, index }) {
     }
     return faker_1.faker.lorem.words(3);
 }
-function generateFieldDataNumber() {
+function generateMockNumber() {
     return faker_1.faker.datatype.float({ precision: 0.1, min: 0, max: 1 }).toString();
 }
-function generateFieldDataBoolean() {
+function generateMockBoolean() {
     return faker_1.faker.datatype.boolean().toString();
 }
-function generateFieldDataDate() {
+function generateMockDate() {
     const d = faker_1.faker.date.past(3, '2023-04-01T00:00:00.000Z');
     //set time to midnight UTC
     d.setUTCHours(0, 0, 0, 0);
     return `new Date('${d.toISOString()}')`;
 }
-function generateFieldDataRelation({ field, itemCount, }) {
-    const referenceId = faker_1.faker.datatype.number({ min: 1, max: itemCount });
+function generateRelationFieldExample({ field, index, model, mode, }) {
+    const referenceId = faker_1.faker.datatype.number({ min: 1, max: mode.itemCount });
     const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
     const brandingFn = refModelMeta.types.toBrandedIdTypeFnName;
-    return `${brandingFn}(${field.unbrandedTypeName === 'string' ? `'${referenceId}'` : referenceId})`;
+    const { hasExample, example } = generateFieldExample({ field, model, index, mode });
+    if (field.unbrandedTypeName === 'string') {
+        if (hasExample && typeof example === 'string') {
+            return `${brandingFn}('${quoteSingleQuote(example)}')`;
+        }
+        return `${brandingFn}('${referenceId}')`;
+    }
+    if (field.unbrandedTypeName === 'number') {
+        if (hasExample && typeof example === 'number') {
+            return `${brandingFn}(${example})`;
+        }
+        return `${brandingFn}(${referenceId})`;
+    }
+    throw new Error(`Unsupported relation id type for ${model.name}.${field.name}: ${field.unbrandedTypeName}`);
 }
-function generateFieldDataEnum({ field, exampleMode, index, }) {
-    if (exampleMode.mode === 'Tuples') {
+function generateEnumFieldExample({ field, mode, index, }) {
+    if (mode.kind === 'Tuples') {
         if (field.attributes.examples) {
             const example = field.attributes.examples[(index - 1) % field.attributes.examples.length];
             return `'${example}'`;

package/package.json

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