@postxl/generator 0.0.1

package/dist/src/lib/meta.d.ts

@@ -0,0 +1,359 @@
+import * as Schema from './schema/schema';
+import * as Types from './schema/types';
+/**
+ * Collection of "global", schema-related values that might be referenced by different generators.
+ */
+export type SchemaMetaData = {
+    data: {
+        /**
+         * Path to the file containing the data module class definition.
+         */
+        dataModuleFilePath: Types.Path;
+        /**
+         * Path to the file containing the mock data for the database.
+         */
+        dataMockModuleFilePath: Types.Path;
+        /**
+         * Path to the file containing data service class definitions.
+         */
+        dataServiceFilePath: Types.Path;
+        /**
+         * Path to the file containing test data service definition.
+         */
+        testDataServiceFilePath: Types.Path;
+        /**
+         * Path to the file containing the index file for the repositories.
+         */
+        repositoriesIndexFilePath: Types.Path;
+        /**
+         * Path to the file containing the index file for the subs.
+         */
+        stubIndexFilePath: Types.Path;
+    };
+    seed: {
+        /**
+         * Path to the index file for the seed package.
+         */
+        indexFilePath: Types.Path;
+        /**
+         * Path that may be used in the import statement.
+         */
+        importPath: Types.Path;
+        /**
+         * Random seed value to use for seeding faker.
+         */
+        randomSeed: number;
+    };
+    trpc: {
+        /**
+         * Path to the file that contains the trpc routes object.
+         */
+        routesFilePath: Types.Path;
+        /**
+         * Path that may be used to import the trpc routes object.
+         */
+        importPath: Types.Path;
+    };
+    types: {
+        /**
+         * Path to the index file for the types package.
+         */
+        indexFilePath: Types.Path;
+        /**
+         * Path that may be used to import the type definitions package.
+         */
+        importPath: Types.Path;
+    };
+};
+/**
+ * Returns a collection of metadata relevant in the global schema context.
+ */
+export declare function getSchemaMetadata({ config }: {
+    config: Schema.SchemaConfig;
+}): SchemaMetaData;
+/**
+ * Collection of values that might be referenced by different generators.
+ */
+export type ModelMetaData = {
+    /**
+     * A user friendly name
+     *
+     * NOTE: User friendly name is very generic and  meant to be used in log messages, errors -
+     *       and any other places where the user shall read about it!
+     *       It is not meant to be used for variables, class names, etc. In code, you should
+     *       use a more specific name for your purposes (e.g. `reactCreateModalComponentName`).
+     */
+    userFriendlyName: string;
+    data: {
+        /**
+         * Path that may be used to import definitions of this model.
+         */
+        importPath: Types.Path;
+        /**
+         * The name of the MockData's property that contains the mock data for this model. (e.g. aggregations)
+         */
+        mockDataPropertyName: Types.VariableName;
+        /**
+         * The path to the file containing stub definitions of this model.
+         */
+        stubFilePath: Types.Path;
+        /**
+         * The name of the TypeScript constant that contains default values for all fields.
+         */
+        defaultStubConstantName: Types.VariableName;
+        /**
+         * The name of the function that adds missing values to the partially populated model value.
+         */
+        stubGenerationFnName: Types.Function;
+        /**
+         * Name of the file containing the repository definition for this model.
+         */
+        repoFileName: Types.FileName;
+        /**
+         * Path to the file containing the repository definition.
+         */
+        repoFilePath: Types.Path;
+        /**
+         * The name of the class for the repository definition of this model (e.g. AggregationRepository).
+         */
+        repositoryClassName: Types.ClassName;
+        /**
+         * The name by which the repository is exposed in the dataService/context. (e.g. aggregations)
+         */
+        dataServiceName: Types.VariableName;
+        /**
+         * The name of the export Excel table (e.g. `Aggregations`).
+         */
+        excelExportTableName: string;
+        repository: {
+            /**
+             * The name of the function that decodes a source (database) object to a fully typed object, e.g. `toAggregation`.
+             */
+            decoderFnName: Types.Function;
+            /**
+             * The name of the method that should be used to get objects from the database, e.g. `aggregations`.
+             */
+            getMethodFnName: Types.Function;
+        };
+    };
+    seed: {
+        /**
+         * The name of the constant containing seed data of this model (e.g. `aggregations`).
+         */
+        constantName: Types.VariableName;
+        /**
+         * Path to the file containing the seed data for this model (e.g. `aggregations.ts`).
+         */
+        filePath: Types.Path;
+        /**
+         * The file or package name that contains the seed data for this model (e.g. `@d2i/aggregations`).
+         */
+        importPath: Types.Path;
+    };
+    react: {
+        /**
+         * Name of the folder that contains React components for this model.
+         */
+        folderName: Types.FolderName;
+        /**
+         * The path to the folder that contains React components for this model.
+         */
+        folderPath: Types.Path;
+        context: {
+            /**
+             * Name of the function that should be used as React hook (e.g. `useAggregation`).
+             */
+            hookFnName: Types.Function;
+            /**
+             * Name of the context wrapper.
+             */
+            testContextProviderName: Types.VariableName;
+            /**
+             * Name of the context wrapper for this model.
+             */
+            contextProviderName: Types.VariableName;
+        };
+        /**
+         * Names of React components that should be generated for this model.
+         *
+         * NOTE: You can assume that these components exist.
+         */
+        components: {
+            modals: {
+                createComponentName: Types.VariableName;
+                editComponentName: Types.VariableName;
+                deleteComponentName: Types.VariableName;
+            };
+            forms: {
+                selectInputName: Types.VariableName;
+                selectFieldName: Types.VariableName;
+                menuSelectInputName: Types.VariableName;
+                menuSelectFieldName: Types.VariableName;
+                searchInputName: Types.VariableName;
+                searchFieldName: Types.VariableName;
+                tableSelectInputName: Types.VariableName;
+                tableSelectFieldName: Types.VariableName;
+            };
+            /**
+             * React component that may be used to list all model instances.
+             */
+            libraryComponentName: Types.VariableName;
+            /**
+             * Name of the generic component containing basic information about a single model instance.
+             */
+            cardComponentName: Types.VariableName;
+        };
+    };
+    trpc: {
+        /**
+         * The path to the file that contains the router definition for this model.
+         */
+        importPath: Types.Path;
+        /**
+         * The absolute path of the file that contains the router definition for this model.
+         */
+        routerFilePath: Types.Path;
+        /**
+         * The name of the router that should be used for this model (e.g. `aggregation`).
+         */
+        routerName: Types.VariableName;
+        getMap: {
+            /**
+             * The name of the TRPC create method (e.g. `create` or `createAggregation`).
+             */
+            methodName: Types.VariableName;
+            /**
+             * The full method name of the React Query method (e.g. `aggregation.create`).
+             */
+            reactQueryMethod: Types.Function;
+        };
+        create: {
+            /**
+             * The name of the TRPC create method (e.g. `create` or `createAggregation`).
+             */
+            methodName: Types.VariableName;
+            /**
+             * The full method name of the React Query method (e.g. `aggregation.create`).
+             */
+            reactQueryMethod: Types.Function;
+        };
+        update: {
+            /**
+             * The name of the TRPC create method (e.g. `create` or `createAggregation`).
+             */
+            methodName: Types.VariableName;
+            /**
+             * The full method name of the React Query method (e.g. `aggregation.create`).
+             */
+            reactQueryMethod: Types.Function;
+        };
+        delete: {
+            /**
+             * The name of the TRPC create method (e.g. `create` or `createAggregation`).
+             */
+            methodName: Types.VariableName;
+            /**
+             * The full method name of the React Query method (e.g. `aggregation.create`).
+             */
+            reactQueryMethod: Types.Function;
+        };
+    };
+    types: {
+        /**
+         * The absolute path of the file that contains the type definition for this model.
+         */
+        filePath: Types.Path;
+        /**
+         * Path that may be used to import the types of this model.
+         */
+        importPath: Types.Path;
+        /**
+         * The name of the type that represents a branded ID, e.g. `AggregationId`.
+         */
+        brandedIdType: Types.TypeName;
+        /**
+         * Function that may be used to convert a scalar value to a branded ID type,
+         * e.g. `toAggregationId`.
+         */
+        toBrandedIdTypeFnName: Types.Function;
+        /**
+         * The name of the function that decodes a source (database) object to a fully typed object, e.g. `aggregationDecoder`.
+         */
+        zodDecoderFnName: Types.Function;
+        /**
+         * The name of the file containing type definitions (e.g. `aggregation.type`).
+         */
+        typeDefFileName: Types.FileName;
+        /**
+         * The name of the type that represents a source (i.e. database) object, e.g. `Aggregation`.
+         */
+        sourceType: Types.TypeName;
+    };
+};
+/**
+ * Returns metadata related to the given model.
+ */
+export declare function getModelMetadata({ model }: {
+    model: Schema.ModelCore;
+}): ModelMetaData;
+type FieldMetaData = {
+    /**
+     * Name of the field as it should appear in the "exposed" properties of the generated type.
+     */
+    tsFieldName: Types.VariableName;
+};
+/**
+ * A collection of hardcoded values shared across multiple generators related to the given field in the model.
+ */
+export declare function getFieldMetadata({ field }: {
+    field: Schema.Field;
+}): FieldMetaData;
+export type EnumMetaData = {
+    react: {
+        /**
+         * Name of the folder that contains React components for this model.
+         */
+        folderName: Types.FolderName;
+        /**
+         * The path to the folder that contains React components for this model.
+         */
+        folderPath: Types.Path;
+        /**
+         * Relative path to the file or a package that contains the React components for this model.
+         */
+        importPath: Types.Path;
+        selectInputName: Types.VariableName;
+        selectFieldName: Types.VariableName;
+        switcherInputName: Types.VariableName;
+        switcherFieldName: Types.VariableName;
+    };
+    types: {
+        /**
+         * Variable that holds a list of all enum members (e.g. `aggregationGroupMembers`).
+         */
+        membersList: Types.VariableName;
+        /**
+         * Variable that holds a map of all enum members (e.g. `aggregationGroup`).
+         */
+        membersMap: Types.VariableName;
+        /**
+         * Relative path to the file that contains the enum's types, e.g. `./aggregation.type`.
+         */
+        filePath: Types.Path;
+        /**
+         * Path that should be used to import enum type definitions.
+         */
+        importPath: Types.Path;
+        /**
+         * Name of the enum as it appears in the source file (e.g. in Prisma schema).
+         */
+        sourceName: string;
+    };
+};
+/**
+ * Returns string values that may be used across multiple generators related to the given enum.
+ */
+export declare function getEnumMetadata({ enumerator: { name, schemaConfig: config }, }: {
+    enumerator: Schema.Enum;
+}): EnumMetaData;
+export {};

package/dist/src/lib/meta.js

@@ -0,0 +1,195 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumMetadata = exports.getFieldMetadata = exports.getModelMetadata = exports.getSchemaMetadata = void 0;
+const Types = __importStar(require("./schema/types"));
+const string_1 = require("./utils/string");
+/**
+ * Returns a collection of metadata relevant in the global schema context.
+ */
+function getSchemaMetadata({ config }) {
+    return {
+        data: {
+            dataModuleFilePath: Types.toPath(`${config.paths.dataLibPath}services/data.module`),
+            dataMockModuleFilePath: Types.toPath(`${config.paths.dataLibPath}services/data.mock.module`),
+            testDataServiceFilePath: Types.toPath(`${config.paths.dataLibPath}services/test-data.service`),
+            dataServiceFilePath: Types.toPath(`${config.paths.dataLibPath}services/data.service`),
+            repositoriesIndexFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/index`),
+            stubIndexFilePath: Types.toPath(`${config.paths.dataLibPath}stubs/index`),
+        },
+        trpc: {
+            routesFilePath: Types.toPath(`${config.paths.trpcRoutesFolderPath}index`),
+            importPath: Types.toPath(`@${config.project}/trpc`),
+        },
+        seed: {
+            indexFilePath: Types.toPath(`${config.paths.seedPath}index`),
+            importPath: Types.toPath(`@${config.project}/seed`),
+            randomSeed: config.randomSeed,
+        },
+        types: {
+            indexFilePath: Types.toPath(`${config.paths.modelTypeDefinitionsPath}index`),
+            importPath: Types.toPath(`@${config.project}/types`),
+        },
+    };
+}
+exports.getSchemaMetadata = getSchemaMetadata;
+/**
+ * Returns metadata related to the given model.
+ */
+function getModelMetadata({ model }) {
+    const { name, schemaConfig: config } = model;
+    const { PascalCase, camelCase, pluralized, uncapitalizedPlural } = (0, string_1.conjugateNames)(name);
+    return {
+        userFriendlyName: PascalCase,
+        data: {
+            mockDataPropertyName: Types.toVariableName(`${uncapitalizedPlural}`),
+            defaultStubConstantName: Types.toVariableName(`${camelCase}DefaultStub`),
+            repoFileName: Types.toFileName(`${camelCase}.repository`),
+            repoFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/${camelCase}.repository`),
+            stubFilePath: Types.toPath(`${config.paths.dataLibPath}stubs/${camelCase}.stub`),
+            importPath: Types.toPath(`@${config.project}/data`),
+            stubGenerationFnName: Types.toFunction(`stub${PascalCase}`),
+            repositoryClassName: Types.toClassName(`${PascalCase}Repository`),
+            dataServiceName: Types.toVariableName(`${uncapitalizedPlural}`),
+            excelExportTableName: `${pluralized}`,
+            repository: {
+                decoderFnName: Types.toFunction(`to${PascalCase}`),
+                getMethodFnName: Types.toFunction(`${camelCase}`),
+            },
+        },
+        seed: {
+            filePath: Types.toPath(`${config.paths.seedPath}${uncapitalizedPlural}`),
+            constantName: Types.toVariableName(`${uncapitalizedPlural}`),
+            importPath: Types.toPath(`@${config.project}/seed`),
+        },
+        react: {
+            folderName: Types.toFolderName(`${PascalCase}`),
+            folderPath: Types.toPath(`${config.paths.reactFolderPath}models/${PascalCase}/`),
+            context: {
+                hookFnName: Types.toFunction(`use${PascalCase}`),
+                testContextProviderName: Types.toVariableName(`${PascalCase}TestContextProvider`),
+                contextProviderName: Types.toVariableName(`${PascalCase}Provider`),
+            },
+            components: {
+                modals: {
+                    createComponentName: Types.toVariableName(`Create${PascalCase}Modal`),
+                    editComponentName: Types.toVariableName(`Edit${PascalCase}Modal`),
+                    deleteComponentName: Types.toVariableName(`Delete${PascalCase}Modal`),
+                },
+                forms: {
+                    selectInputName: Types.toVariableName(`${PascalCase}SelectInput`),
+                    selectFieldName: Types.toVariableName(`${PascalCase}SelectField`),
+                    menuSelectInputName: Types.toVariableName(`${PascalCase}MenuSelectInput`),
+                    menuSelectFieldName: Types.toVariableName(`${PascalCase}MenuSelectField`),
+                    searchInputName: Types.toVariableName(`${PascalCase}SearchInput`),
+                    searchFieldName: Types.toVariableName(`${PascalCase}SearchField`),
+                    tableSelectInputName: Types.toVariableName(`${PascalCase}TableSelectInput`),
+                    tableSelectFieldName: Types.toVariableName(`${PascalCase}TableSelectField`),
+                },
+                libraryComponentName: Types.toVariableName(`${PascalCase}Library`),
+                cardComponentName: Types.toVariableName(`${PascalCase}Card`),
+            },
+        },
+        trpc: {
+            routerFilePath: Types.toPath(`${config.paths.trpcRoutesFolderPath}${camelCase}.router`),
+            routerName: Types.toVariableName(camelCase),
+            importPath: Types.toPath(`@${config.project}${camelCase}.router`),
+            getMap: {
+                methodName: Types.toVariableName('getMap'),
+                reactQueryMethod: Types.toFunction(`${camelCase}.getMap`),
+            },
+            create: {
+                methodName: Types.toVariableName('create'),
+                reactQueryMethod: Types.toFunction(`${camelCase}.create`),
+            },
+            update: {
+                methodName: Types.toVariableName('update'),
+                reactQueryMethod: Types.toFunction(`${camelCase}.update`),
+            },
+            delete: {
+                methodName: Types.toVariableName('delete'),
+                reactQueryMethod: Types.toFunction(`${camelCase}.delete`),
+            },
+        },
+        types: {
+            importPath: Types.toPath(`@${config.project}/types`),
+            filePath: Types.toPath(`${config.paths.modelTypeDefinitionsPath}${camelCase}.type`),
+            brandedIdType: Types.toTypeName(`${PascalCase}Id`),
+            toBrandedIdTypeFnName: Types.toFunction(`to${PascalCase}Id`),
+            zodDecoderFnName: Types.toFunction(`${camelCase}Decoder`),
+            typeDefFileName: Types.toFileName(`${camelCase}.type`),
+            sourceType: Types.toTypeName(`${PascalCase}`),
+        },
+    };
+}
+exports.getModelMetadata = getModelMetadata;
+/**
+ * A collection of hardcoded values shared across multiple generators related to the given field in the model.
+ */
+function getFieldMetadata({ field }) {
+    switch (field.kind) {
+        case 'id':
+            return {
+                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
+            };
+        case 'enum':
+            return {
+                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
+            };
+        case 'relation':
+            return {
+                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
+            };
+        case 'scalar':
+            return {
+                tsFieldName: Types.toVariableName((0, string_1.toCamelCase)(field.name)),
+            };
+    }
+}
+exports.getFieldMetadata = getFieldMetadata;
+/**
+ * Returns string values that may be used across multiple generators related to the given enum.
+ */
+function getEnumMetadata({ enumerator: { name, schemaConfig: config }, }) {
+    return {
+        react: {
+            folderName: Types.toFolderName((0, string_1.toPascalCase)(name)),
+            folderPath: Types.toPath(`${config.paths.reactFolderPath}/enums/${(0, string_1.toPascalCase)(name)}`),
+            importPath: Types.toPath(`@${config.project}/react/enums/${(0, string_1.toPascalCase)(name)}`),
+            selectInputName: Types.toVariableName(`${(0, string_1.toPascalCase)(name)}SelectInput`),
+            selectFieldName: Types.toVariableName(`${(0, string_1.toPascalCase)(name)}SelectField`),
+            switcherInputName: Types.toVariableName(`${(0, string_1.toPascalCase)(name)}SwitcherInput`),
+            switcherFieldName: Types.toVariableName(`${(0, string_1.toPascalCase)(name)}SwitcherField`),
+        },
+        types: {
+            membersList: Types.toVariableName(`${(0, string_1.toCamelCase)(name)}Members`),
+            membersMap: Types.toVariableName(`${(0, string_1.toCamelCase)(name)}`),
+            filePath: Types.toPath(`${config.paths.modelTypeDefinitionsPath}${(0, string_1.toCamelCase)(name)}.enum`),
+            importPath: Types.toPath(`@${config.project}/types`),
+            sourceName: name,
+        },
+    };
+}
+exports.getEnumMetadata = getEnumMetadata;

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

@@ -0,0 +1,35 @@
+import { Field, FieldEnum, FieldRelation, FieldScalar } from './schema';
+/**
+ * The default field of the model.
+ * Note: A model can only have one or no default field!
+ * This is enforced by the schema validation.
+ */
+export declare const getDefaultField: ({ fields }: {
+    fields: Field[];
+}) => FieldScalar | undefined;
+/**
+ * List of all scalar fields of the model (excluding foreing keys and the id)
+ */
+export declare const getScalarFields: ({ fields }: {
+    fields: Field[];
+}) => FieldScalar[];
+/**
+ * List of all relation fields of the model.
+ */
+export declare const getRelationFields: ({ fields }: {
+    fields: Field[];
+}) => FieldRelation[];
+/**
+ * List of all enum fields of the model.
+ */
+export declare const getEnumFields: ({ fields }: {
+    fields: Field[];
+}) => FieldEnum[];
+/**
+ * Returns a default value for a TypeScript type.
+ */
+export declare const getDefaultValueForType: (type: string) => string;
+/**
+ * Returns true if the given field is unique and a string field.
+ */
+export declare const isUniqueStringField: (f: Field) => boolean;

package/dist/src/lib/schema/fields.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUniqueStringField = exports.getDefaultValueForType = exports.getEnumFields = exports.getRelationFields = exports.getScalarFields = exports.getDefaultField = void 0;
+/**
+ * The default field of the model.
+ * Note: A model can only have one or no default field!
+ * This is enforced by the schema validation.
+ */
+const getDefaultField = ({ fields }) => fields.find((f) => f.attributes.isDefaultField);
+exports.getDefaultField = getDefaultField;
+/**
+ * List of all scalar fields of the model (excluding foreing keys and the id)
+ */
+const getScalarFields = ({ fields }) => fields.filter((f) => f.kind === 'scalar');
+exports.getScalarFields = getScalarFields;
+/**
+ * List of all relation fields of the model.
+ */
+const getRelationFields = ({ fields }) => fields.filter((f) => f.kind === 'relation');
+exports.getRelationFields = getRelationFields;
+/**
+ * List of all enum fields of the model.
+ */
+const getEnumFields = ({ fields }) => fields.filter((f) => f.kind === 'enum');
+exports.getEnumFields = getEnumFields;
+/**
+ * Returns a default value for a TypeScript type.
+ */
+const getDefaultValueForType = (type) => {
+    switch (type) {
+        case 'number':
+            return '0';
+        case 'string':
+            return "''";
+        case 'boolean':
+            return 'true';
+        case 'Date':
+            return 'new Date()';
+        default:
+            return '{} as any';
+    }
+};
+exports.getDefaultValueForType = getDefaultValueForType;
+/**
+ * Returns true if the given field is unique and a string field.
+ */
+const isUniqueStringField = (f) => (f.kind === 'id' && f.isUnique && f.unbrandedTypeName === 'string') ||
+    (f.kind === 'scalar' && f.isUnique && f.typeName === 'string');
+exports.isUniqueStringField = isUniqueStringField;