@postxl/generator 0.38.2 → 0.40.0

package/dist/generators/models/importexport-decoder.generator.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportDecoderIndex = exports.generateImportExportDecoder = exports.generateModelImportExportDecoder = void 0;
+const exports_1 = require("../../lib/exports");
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+const types_2 = require("../../lib/types");
+// TODO: Remove hardcoded path that seems to be reused in multiple places!
+const PXL_COMMON = (0, types_1.toPath)('@pxl/common');
+/**
+ * Creates a decoder for the Seed Excel template.
+ */
+function generateModelImportExportDecoder({ model, meta }) {
+    const { filePath: decoderFilePath, itemEncoderFunctionName: rowExportFunctionName, encodedExcelType: excelType, arrayEncoderFunctionName: tableExportFunctionName, tableDecoder: tableImportDecoder, } = meta.importExport.decoder;
+    const imports = imports_1.ImportsGenerator.from(decoderFilePath);
+    imports.addImports({
+        [PXL_COMMON]: [
+            (0, types_1.toFunctionName)('uncapitalizeKeys'),
+            (0, types_1.toFunctionName)('capitalizeKeys'),
+            (0, types_1.toFunctionName)('nullOrBlankDecoder'),
+        ],
+        [meta.types.importPath]: [meta.types.typeName],
+    });
+    const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural, internalSingularName: singular, internalSingularNameCapitalized: singularCapitalized, } = meta;
+    const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, imports });
+    return `
+import * as z from 'zod'
+${imports.generate()}
+
+/**
+* The decoder for an Excel row containing a ${userFriendly} entry
+*/
+const ${singular}ExcelRowImportDecoderInput = z.object({
+  ${fieldDecoders.join(',\n')}
+})
+
+
+/**
+ * The type for rows in the ${userFriendly} table
+ */
+export type ${excelType} = z.infer<typeof ${singular}ExcelRowImportDecoderInput>
+
+const ${singular}ExcelRowImportDecoder = ${singular}ExcelRowImportDecoderInput.transform(uncapitalizeKeys)
+
+/**
+ * The decoder to identify blank rows in the ${userFriendly} table
+ */
+const blank${singularCapitalized}ExcelRowImportDecoderInput = z
+  .object({
+    ${blankFieldDecoders.join(',\n')}
+  })
+  .transform(() => undefined)
+
+/**
+ * The decoder for an Excel table that contains ${userFriendly} entries
+ */
+export const ${tableImportDecoder} = z
+  .array(${singular}ExcelRowImportDecoder.or(blank${singularCapitalized}ExcelRowImportDecoderInput))
+  .transform((items) => items.filter(Boolean) as ${model.typeName}[])
+
+/**
+ * Converts a ${userFriendly} to an Excel row
+ */
+export const ${rowExportFunctionName} = (item: ${model.typeName}): ${excelType} => capitalizeKeys(item)
+
+/**
+ * Converts a list of ${userFriendlyPlural} to an Excel table
+ */
+export const ${tableExportFunctionName} = (items: ${model.typeName}[]): ${excelType}[] => items.map(${rowExportFunctionName})
+  `;
+}
+exports.generateModelImportExportDecoder = generateModelImportExportDecoder;
+function generateFieldDecoders({ model, meta, imports, }) {
+    const fieldDecoders = [];
+    const blankFieldDecoders = [];
+    for (const field of model.fields) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
+        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: nullOrBlankDecoder`);
+        switch (field.kind) {
+            case 'id': {
+                imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    tsTypeName: field.unbrandedTypeName,
+                    dbTypeName: field.schemaType,
+                    nullable: false,
+                    imports,
+                })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
+                break;
+            }
+            case 'scalar': {
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    tsTypeName: field.tsTypeName,
+                    dbTypeName: field.schemaType,
+                    nullable: !field.isRequired,
+                    imports,
+                })}`);
+                break;
+            }
+            case 'relation': {
+                const refModel = field.relationToModel;
+                const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+                imports.addImport({ items: [refMeta.types.toBrandedIdTypeFnName], from: refMeta.types.importPath });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    tsTypeName: field.unbrandedTypeName,
+                    dbTypeName: field.schemaType,
+                    nullable: !field.isRequired,
+                    imports,
+                })}
+          .transform(
+            (id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => 
+              ${field.isRequired ? '' : ' id === null ? null : '}${refMeta.types.toBrandedIdTypeFnName}(id)
+          )`);
+                break;
+            }
+            case 'enum': {
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([
+            ${field.enumerator.values.map((v) => `'${v}'`).join(', ')}
+          ])${field.isRequired ? '' : '.nullable()'}`);
+                break;
+            }
+            default: {
+                throw new types_2.ExhaustiveSwitchCheck(field);
+            }
+        }
+    }
+    return { fieldDecoders, blankFieldDecoders };
+}
+function toExcelDecoder({ tsTypeName, dbTypeName: typeName, nullable, imports, }) {
+    switch (tsTypeName) {
+        case 'string': {
+            const decoder = (0, types_1.toFunctionName)(nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
+        case 'boolean':
+            imports.addImport({
+                items: [(0, types_1.toFunctionName)('excelBooleanDecoder')],
+                from: PXL_COMMON,
+            });
+            return 'excelBooleanDecoder';
+        case 'number':
+            switch (typeName) {
+                case 'Int':
+                case 'BigInt':
+                    return `z.number().int()${nullable ? '.nullable()' : ''}`;
+                default:
+                    return `z.number()${nullable ? '.nullable()' : ''}`;
+            }
+        case 'Date': {
+            const decoder = (0, types_1.toFunctionName)(nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
+        default:
+            throw new Error('Unknown type');
+    }
+}
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+function generateImportExportDecoder({ models, meta }) {
+    const { decodedPXLModelDataTypeName, encodedExcelDataTypeName, fullDecoderName, fullEncoderFunctionName } = meta.importExport.decoder;
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.decoder.fullDecoderFilePath);
+    imports.addImports({
+        [PXL_COMMON]: (0, types_1.toFunctionName)('uncapitalizeKeys'),
+    });
+    const importTypes = [];
+    const decoderEntries = [];
+    const exportFields = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            from: modelMeta.importExport.decoder.filePath,
+            items: [
+                modelMeta.importExport.decoder.tableDecoder,
+                modelMeta.importExport.decoder.arrayEncoderFunctionName,
+                modelMeta.importExport.decoder.encodedExcelType,
+            ],
+        });
+        importTypes.push(`${modelMeta.importExport.tableName}?: ${modelMeta.importExport.decoder.encodedExcelType}[]`);
+        decoderEntries.push(`${modelMeta.importExport.tableName}: ${modelMeta.importExport.decoder.tableDecoder}.optional()`);
+        exportFields.push(`${modelMeta.importExport.tableName}: 
+      data.${modelMeta.importExport.exportDataFullPropertyName} !== undefined ?
+        ${modelMeta.importExport.decoder.arrayEncoderFunctionName}(data.${modelMeta.importExport.exportDataFullPropertyName}) 
+        : undefined`);
+    }
+    return `
+import * as z from 'zod'
+${imports.generate()}
+
+export type ${encodedExcelDataTypeName} = {
+  ${importTypes.join(',\n')}
+}
+
+/**
+ * Decoder that converts Excel data to model data
+ */
+export const ${fullDecoderName} = z
+  .object({
+    ${decoderEntries.join(',\n')}
+  })
+  .transform(uncapitalizeKeys)
+
+export type ${decodedPXLModelDataTypeName} = z.infer<typeof excelDataDecoder>
+
+/**
+ * Converts the model data to Excel format
+ */
+export const ${fullEncoderFunctionName} = (data: ${decodedPXLModelDataTypeName}): ${encodedExcelDataTypeName} => ({
+  ${exportFields.join(',\n')}
+})
+`;
+}
+exports.generateImportExportDecoder = generateImportExportDecoder;
+/**
+ * Generates the index file for all the routes.
+ */
+function generateImportExportDecoderIndex({ models, meta }) {
+    const exports = exports_1.ExportsGenerator.from(meta.importExport.decoder.indexFilePath);
+    exports.exportEverythingFromPath(meta.importExport.decoder.fullDecoderFilePath);
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(modelMeta.importExport.decoder.filePath);
+    }
+    return exports.generate();
+}
+exports.generateImportExportDecoderIndex = generateImportExportDecoderIndex;

package/dist/generators/models/react.generator/library.generator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelLibraryComponents = void 0;
+const id_collector_1 = require("../../../lib/id-collector");
 const imports_1 = require("../../../lib/imports");
 /**
  * Generates components that may be used to list all entries of a given data type.
@@ -10,6 +11,7 @@ const imports_1 = require("../../../lib/imports");
  */
 function generateModelLibraryComponents({ model, meta }) {
     const { react: { context, components }, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-card');
     const imports = imports_1.ImportsGenerator.from(meta.react.folderPath)
         .addImport({
         items: [model.typeName],
@@ -58,11 +60,13 @@ function generateModelLibraryComponents({ model, meta }) {
                   label: 'Edit',
                   icon: 'pencil-on-paper',
                   onClick: () => setIsEditModalOpen(true),
+                  __cypress_action_selector__: "${selectorCollector.idFor('edit', { typePrefix: 'actions' })}",
                 },
                 {
                   label: 'Delete',
                   icon: 'trash',
                   onClick: () => setIsDeleteModalOpen(true),
+                  __cypress_action_selector__: "${selectorCollector.idFor('delete', { typePrefix: 'actions' })}",
                 },
               ]}
             />

package/dist/generators/models/react.generator/modals.generator.js

@@ -24,6 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDeleteModalModelComponent = exports.generateEditModalModelComponent = exports.generateModelCreateModalComponent = void 0;
+const id_collector_1 = require("../../../lib/id-collector");
 const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const fields_1 = require("../../../lib/schema/fields");
@@ -36,6 +37,7 @@ const StringUtils = __importStar(require("../../../lib/utils/string"));
 function generateModelCreateModalComponent({ model, meta }) {
     const { fields } = model;
     const { react: { components: { modals }, }, trpc, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-createModal');
     return `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 ${getFormImports({ model, meta })}
@@ -130,9 +132,10 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
               fill="fill"
               onClick={submitForm}
               loading={isSubmitting}
+              __cypress_selector__="${selectorCollector.idFor('submit', { typePrefix: 'buttons' })}"
             />
 					}>
-						${getFormFieldComponents({ model })}
+						${getFormFieldComponents({ model, selectorCollector })}
           </ModalWithActions>
         )}
       </Typed.Formik>
@@ -149,6 +152,7 @@ exports.generateModelCreateModalComponent = generateModelCreateModalComponent;
 function generateEditModalModelComponent({ model, meta }) {
     const { fields } = model;
     const { react: { components }, trpc, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-editModal');
     return `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 ${getFormImports({ model, meta })}
@@ -257,10 +261,11 @@ export const ${components.modals.editComponentName} = ({
                 color="primary"
                 onClick={submitForm}
                 loading={isSubmitting}
+                __cypress_selector__="${selectorCollector.idFor('submit', { typePrefix: 'buttons' })}"
               />
             }
           >
-            ${getFormFieldComponents({ model })}
+            ${getFormFieldComponents({ model, selectorCollector })}
           </ModalWithActions>
         )}
       </Typed.Formik>
@@ -528,7 +533,7 @@ function getEditFormikMutationData({ model: { fields } }) {
 /**
  * Returns a string containing all the components that should appear in the Formik form for this model.
  */
-function getFormFieldComponents({ model }) {
+function getFormFieldComponents({ model, selectorCollector, }) {
     var _a;
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
@@ -550,7 +555,11 @@ function getFormFieldComponents({ model }) {
                         form.append(`
               <div>
                 <Label>${label}</Label>
-                <Typed.TextField placeholder="Type..." name="${formikFieldName}" />
+                <Typed.TextField 
+                  name="${formikFieldName}"
+                  placeholder="Type..."
+                  __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+                />
               </div>
             `);
                         break scalar;
@@ -563,7 +572,12 @@ function getFormFieldComponents({ model }) {
                         form.append(`
               <div>
                 <Label>${label}</Label>
-                <Typed.NumberField placeholder="2511" name="${formikFieldName}" decimals={${decimals}}/>
+                <Typed.NumberField 
+                  name="${formikFieldName}"
+                  placeholder="2511"
+                  decimals={${decimals}}
+                  __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+                />
               </div>
             `);
                         break scalar;
@@ -572,7 +586,11 @@ function getFormFieldComponents({ model }) {
                         form.append(`
               <div>
                 <Label>Is ${label}</Label>
-                <Typed.CheckBoxField label="${label}" name="${formikFieldName}" />
+                <Typed.CheckBoxField 
+                  name="${formikFieldName}" 
+                  label="${label}" 
+                  __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+                />
               </div>
             `);
                         break scalar;
@@ -593,7 +611,12 @@ function getFormFieldComponents({ model }) {
                 form.append(`
           <div>
             <Label>${refMeta.userFriendlyName}</Label>
-            <Typed.${refMeta.react.components.forms.searchFieldName} name="${formikFieldName}" placeholder="Search..." />
+            <Typed.${refMeta.react.components.forms.searchFieldName} 
+              name="${formikFieldName}" 
+              placeholder="Search..." 
+              __cypress_options_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'options' })}"
+              __cypress_combobox_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+            />
           </div>
         `);
                 break;
@@ -603,7 +626,11 @@ function getFormFieldComponents({ model }) {
                 form.append(`
           <div>
             <Label>${label}</Label>
-            <Typed.${enumMeta.react.selectFieldName} name="${formikFieldName}" placeholder="Search..." />
+            <Typed.${enumMeta.react.selectFieldName} 
+              name="${formikFieldName}" 
+              placeholder="Search..." 
+              __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+            />
           </div>
         `);
                 break;