@postxl/generator 0.0.1

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

@@ -0,0 +1,275 @@
+import { FieldAttributes, ModelAttributes } from '../attributes';
+import { Prettify } from '../utils/types';
+import * as Types from './types';
+/**
+ * A shared configuration of the schema.
+ *
+ * NOTE: This may be accessed in every model, field and enumerator.
+ */
+export type SchemaConfig = {
+    /**
+     * Project scope to use in TypeScript imports (e.g. `mca` for `@mca/types`).
+     */
+    project: string;
+    paths: {
+        /**
+         * Path to the directory containing model type definitions.
+         *
+         * NOTE: Metadata assumes that project is set up so that certain parts of the code
+         * may reference type definitions using `@project/types` import.
+         */
+        modelTypeDefinitionsPath: Types.Path;
+        /**
+         * Path to the directory containing data library definitions.
+         *
+         * NOTE: Metadata assumes that project is set up so that certain parts of the code
+         * may reference data library using `@project/data` import.
+         */
+        dataLibPath: Types.Path;
+        /**
+         * Path to the directory containing mock data samples.
+         *
+         * NOTE: Metadata assumes that project is set up so that certain parts of the code
+         * may reference mock data using `@project/seed` import.
+         */
+        seedPath: Types.Path;
+        /**
+         * Path to the directory containing React components.
+         *
+         * NOTE: Metadata assumes that the project is set up so that React components
+         * may be referenced using `@project/react` import.
+         */
+        reactFolderPath: Types.Path;
+        /**
+         * Path to the directory containing trpc routes.
+         */
+        trpcRoutesFolderPath: Types.Path;
+    };
+    /**
+     * Seed to use for random generation.
+     */
+    randomSeed: number;
+    /**
+     * Whether the generator should overwrite existing files.
+     */
+    force: boolean;
+};
+export type Model = Prettify<ModelCore & ModelFields>;
+/**
+ * The model's core properties (i.e. without fields)
+ */
+export type ModelCore = {
+    /**
+     * Name of the model (e.g. Aggregation)
+     */
+    name: string;
+    /**
+     * Description of the model, ideally providing business background and detailed information
+     */
+    description?: string;
+    /**
+     * Name of the models type (e.g. Aggregation)
+     */
+    typeName: Types.TypeName;
+    /**
+     * Name of the model in the source, e.g. in the database (e.g. aggregation)
+     *
+     * Note: Should be only relevant to repository generator
+     * @internal
+     */
+    sourceName: string;
+    /**
+     * Type of the ID field that is specific to this model, e.g. `AggregationId`.
+     */
+    brandedIdType: Types.TypeName;
+    /**
+     * Attributes of the model
+     * @see ModelAttributes
+     */
+    attributes: ModelAttributes;
+    /**
+     * A global schema configuration.
+     */
+    schemaConfig: SchemaConfig;
+};
+export type ModelFields = {
+    /**
+     * The id field of the model
+     */
+    idField: FieldId;
+    /**
+     * The property of the model that identifies the default row.
+     */
+    defaultField?: Field;
+    /**
+     * The property of the model that is used to define the name/label
+     *
+     * By default, this is maps to the `name` field - but using the `@label` attribute, other fields can be used.
+     */
+    nameField?: FieldScalar;
+    /**
+     * All fields of the model
+     */
+    fields: Field[];
+};
+/**
+ * A field of a model.
+ * Note: Different field types are represented as discriminant unions.
+ */
+export type Field = FieldId | FieldScalar | FieldRelation | FieldEnum;
+/**
+ * The properties shared by all field types.
+ */
+export type FieldCore = {
+    /**
+     * Name of the field and variable (e.g. name)
+     *
+     * Note: The type of the name is narrowed by each field type.
+     */
+    name: string;
+    /**
+     * Description of the field, ideally providing business background and detailed information
+     */
+    description?: string;
+    /**
+     * True if the field is not nullable.
+     */
+    isRequired: boolean;
+    /**
+     * A dictionary of raw attributes of the model indexed by their name.
+     */
+    attributes: FieldAttributes;
+    /**
+     * Name of the field in the source e.g. in the database (e.g. Id)
+     */
+    sourceName: string;
+    /**
+     * Validation rule for the field.
+     */
+    validation?: Validation;
+    /**
+     * A global schema configuration.
+     */
+    schemaConfig: SchemaConfig;
+};
+export type Validation = {
+    type: 'int';
+} | {
+    type: 'float';
+};
+/**
+ * A scalar field, i.e. a string, number, boolean, Date
+ */
+export type FieldScalar = Prettify<Omit<FieldCore, 'name'> & {
+    kind: 'scalar';
+    /**
+     * Name of the field and variable (e.g. name)
+     */
+    name: string;
+    /**
+     * Name of the scalar TypeScript type, e.g. string
+     */
+    typeName: Types.TypeName;
+    /**
+     * If true, each element is unique.
+     * Note: This is ensured by the repository/database
+     */
+    isUnique: boolean;
+    /**
+     * True if the id field is an autoIncremented field.
+     */
+    isGenerated: boolean;
+}>;
+/**
+ * The id field of a model. A model can only have one id field.
+ */
+export type FieldId = Prettify<Omit<FieldCore, 'name'> & {
+    kind: 'id';
+    /**
+     * Name of the field and variable (e.g. id)
+     */
+    name: string;
+    /**
+     * Model that this ID field identifies.
+     */
+    model: ModelCore;
+    /**
+     * If true, each element is unique.
+     * Note: This is ensured by the repository/database
+     */
+    isUnique: boolean;
+    /**
+     * True if the id field is an autoIncremented field.
+     */
+    isGenerated: boolean;
+    /**
+     * Name of the unbranded TypeScript type of the id field, e.g. string
+     *
+     * Note: This should only be used in the type generator - all other generators
+     * should use the branded type "typeName"!
+     */
+    unbrandedTypeName: Types.TypeName;
+}>;
+/**
+ * A relation field, representing a "to-relation" in the schema.
+ */
+export type FieldRelation = Prettify<Omit<FieldCore, 'name'> & {
+    kind: 'relation';
+    /**
+     * Name of the field and variable (e.g. aggregationId)
+     */
+    name: string;
+    /**
+     * Name of the unbranded TypeScript type of the field, e.g. string
+     *
+     * Note: This should only be used in the type generator - all other generators
+     * should use the branded type "typeName"!
+     *
+     * @internal
+     */
+    unbrandedTypeName: Types.TypeName;
+    /**
+     * The referenced model
+     */
+    relationToModel: ModelCore;
+}>;
+/**
+ * An enum field, e.g. a field that can only have a value of a specific enum.
+ */
+export type FieldEnum = Prettify<Omit<FieldCore, 'name'> & {
+    kind: 'enum';
+    /**
+     * Name of the field and variable (e.g. language)
+     */
+    name: string;
+    /**
+     * Name of the TypeScript type of the field, e.g. Language
+     */
+    typeName: Types.TypeName;
+    /**
+     * Enum definition of the field.
+     */
+    enumerator: Enum;
+}>;
+/**
+ * Definition of an enum, consisting of a name and a list of enum members.
+ */
+export type Enum = {
+    name: string;
+    /**
+     * TypeScript type that should be used to reference an enumerator.
+     */
+    typeName: Types.TypeName;
+    /**
+     * Name of the enum as it appears in the source (e.g. in the Prisma file).
+     */
+    sourceName: string;
+    /**
+     * List of enum members, e.g. [EN, DE]
+     */
+    values: string[];
+    /**
+     * A global schema configuration.
+     */
+    schemaConfig: SchemaConfig;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,72 @@
+/**
+ * Name of a Typescript type, e.g. "Aggregation".
+ */
+export type TypeName = string & {
+    readonly typeName: unique symbol;
+};
+/**
+ * Brands a raw string to a TypeScript Type identifier.
+ */
+export declare const toTypeName: (t: string) => TypeName;
+/**
+ * The name of a function (e.g. "toAggregation").
+ */
+export type Function = string & {
+    readonly functionName: unique symbol;
+};
+/**
+ * Converts a string to a branded function name.
+ */
+export declare const toFunction: (t: string) => Function;
+/**
+ * The name of a class, e.g. "AggregationRepository".
+ */
+export type ClassName = string & {
+    readonly className: unique symbol;
+};
+/**
+ * Converts a raw string to a branded ClassName.
+ */
+export declare const toClassName: (t: string) => ClassName;
+/**
+ * The name of a variable or a property in the generated code.
+ */
+export type VariableName = string & {
+    readonly variableName: unique symbol;
+};
+/**
+ * Converts a string to a branded VariableName.
+ */
+export declare const toVariableName: (t: string) => VariableName;
+/**
+ * A name of the file without a file extension, e.g. "aggregation.type".
+ */
+export type FileName = string & {
+    readonly fileName: unique symbol;
+};
+/**
+ * Lets you brand a string value as a name of the file.
+ *
+ * NOTE: THIS SHOULD NOT BE A PATH!
+ */
+export declare const toFileName: (t: string) => FileName;
+/**
+ * A name of the folder without the trailing and leading slash (e.g. "aggregation").
+ */
+export type FolderName = string & {
+    readonly folderName: unique symbol;
+};
+/**
+ * Converts a string to a branded FolderName.
+ */
+export declare const toFolderName: (t: string) => FolderName;
+/**
+ * A relative or absolute path to a file or folder.
+ */
+export type Path = string & {
+    readonly fileName: unique symbol;
+};
+/**
+ * Converts a string to a branded FileName.
+ */
+export declare const toPath: (t: string) => Path;

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

@@ -0,0 +1,41 @@
+"use strict";
+// MARK: - Generated content related types
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPath = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toClassName = exports.toFunction = exports.toTypeName = void 0;
+/**
+ * Brands a raw string to a TypeScript Type identifier.
+ */
+const toTypeName = (t) => t;
+exports.toTypeName = toTypeName;
+/**
+ * Converts a string to a branded function name.
+ */
+const toFunction = (t) => t;
+exports.toFunction = toFunction;
+/**
+ * Converts a raw string to a branded ClassName.
+ */
+const toClassName = (t) => t;
+exports.toClassName = toClassName;
+/**
+ * Converts a string to a branded VariableName.
+ */
+const toVariableName = (t) => t;
+exports.toVariableName = toVariableName;
+/**
+ * Lets you brand a string value as a name of the file.
+ *
+ * NOTE: THIS SHOULD NOT BE A PATH!
+ */
+const toFileName = (t) => t;
+exports.toFileName = toFileName;
+/**
+ * Converts a string to a branded FolderName.
+ */
+const toFolderName = (t) => t;
+exports.toFolderName = toFolderName;
+/**
+ * Converts a string to a branded FileName.
+ */
+const toPath = (t) => t;
+exports.toPath = toPath;

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

@@ -0,0 +1,8 @@
+import { Field } from './schema';
+/**
+ * Returns the string defining the zod decoder for a given field.
+ */
+export declare const getZodDecoderDefinition: ({ field, allowAnyOptionalField, }: {
+    field: Field;
+    allowAnyOptionalField?: boolean | undefined;
+}) => string;

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZodDecoderDefinition = void 0;
+const assert_never_1 = __importDefault(require("assert-never"));
+const meta_1 = require("../meta");
+/**
+ * Returns the string defining the zod decoder for a given field.
+ */
+const getZodDecoderDefinition = ({ field, allowAnyOptionalField, }) => {
+    let definition = getZodTypeDefinition(field);
+    if (field.kind === 'id') {
+        const idModelMeta = (0, meta_1.getModelMetadata)({ model: field.model });
+        definition += `.transform(${idModelMeta.types.toBrandedIdTypeFnName})`;
+    }
+    if (field.kind === 'relation') {
+        const refModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
+        definition += `.transform(${refModelMeta.types.toBrandedIdTypeFnName})`;
+    }
+    if (!field.isRequired) {
+        definition += `.nullable()`;
+    }
+    if (allowAnyOptionalField) {
+        definition += `.optional()`;
+    }
+    return definition;
+};
+exports.getZodDecoderDefinition = getZodDecoderDefinition;
+function getZodTypeDefinition(field) {
+    switch (field.kind) {
+        case 'scalar':
+            return `${field.typeName}()`;
+        case 'enum':
+            return `enum([${field.enumerator.values.map((v) => `'${v}'`).join(', ')}])`;
+        case 'id':
+            return `${field.unbrandedTypeName}()`;
+        case 'relation':
+            return `${field.unbrandedTypeName}()`;
+        default:
+            (0, assert_never_1.default)(field);
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Lets you serialize a string content easily.
+ */
+export declare class Serializer {
+    private _content;
+    constructor();
+    /**
+     * Appends given content to the file and inserts a newline.
+     */
+    append(content: string): void;
+    /**
+     * Returns the contents of the serializer.
+     */
+    print(): string;
+}

package/dist/src/lib/serializer.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serializer = void 0;
+/**
+ * Lets you serialize a string content easily.
+ */
+class Serializer {
+    constructor() {
+        this._content = '';
+    }
+    /**
+     * Appends given content to the file and inserts a newline.
+     */
+    append(content) {
+        this._content += `${content}\n`;
+    }
+    /**
+     * Returns the contents of the serializer.
+     */
+    print() {
+        return this._content;
+    }
+}
+exports.Serializer = Serializer;

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

@@ -0,0 +1,5 @@
+/**
+ * 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.
+ */
+export declare function throwError(message: string): never;

package/dist/src/lib/utils/error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ */
+function throwError(message) {
+    const m = ` ❌❌❌ ${message}`;
+    console.error(m);
+    throw new Error(m);
+}
+exports.throwError = throwError;

package/dist/src/lib/utils/file.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the relative path from one file (e.g. current file) to another file
+ * assuming that both files have the same starting point (e.g. from `/a` to `/b/c` is `./b/c`).
+ *
+ * If the referenced file is a package, then we return the package reference (e.g. `@lib/package`).
+ */
+export declare function getRelativePath({ from, to }: {
+    from: string;
+    to: string;
+}): string;

package/dist/src/lib/utils/file.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativePath = void 0;
+/**
+ * Returns the relative path from one file (e.g. current file) to another file
+ * assuming that both files have the same starting point (e.g. from `/a` to `/b/c` is `./b/c`).
+ *
+ * If the referenced file is a package, then we return the package reference (e.g. `@lib/package`).
+ */
+function getRelativePath({ from, to }) {
+    if (to.startsWith('@')) {
+        return to;
+    }
+    const fromParts = _resolvePath(from);
+    const toParts = _resolvePath(to);
+    // NOTE: We expect that from value references a file of a file in a given folder.
+    // Relative to that file, we need to remove it.
+    fromParts.pop();
+    // Remove common parts.
+    while (fromParts.length > 0 && toParts.length > 0 && fromParts[0] === toParts[0]) {
+        fromParts.shift();
+        toParts.shift();
+    }
+    // Add ../ for each remaining part in fromParts.
+    const relativePath = fromParts
+        .map(() => '..')
+        .concat(toParts)
+        .join('/');
+    if (relativePath.startsWith('.')) {
+        return relativePath;
+    }
+    return `./${relativePath}`;
+}
+exports.getRelativePath = getRelativePath;
+/**
+ * Returns a list of folders leading from the root to the referenecd file or folder and removes
+ * any positional paths.
+ */
+function _resolvePath(path) {
+    const chunks = path.split('/');
+    const resolved = [];
+    while (chunks.length > 0) {
+        const chunk = chunks.shift();
+        if (chunk === '..') {
+            resolved.pop();
+            continue;
+        }
+        if (chunk === '.') {
+            continue;
+        }
+        resolved.push(chunk);
+    }
+    return resolved;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * A generic logger interface.
+ * Compatible with the `@prisma/internals` logger and console.
+ */
+export interface Logger {
+    log(...data: any[]): void;
+    warn(message: any, ...optionalParams: any[]): void;
+    info(message: any, ...optionalParams: any[]): void;
+    error(message: any, ...optionalParams: any[]): void;
+    query(message: any, ...optionalParams: any[]): void;
+}

package/dist/src/lib/utils/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/lib/utils/string.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Returns the same string with a lowercase first letter.
+ */
+export declare const uncapitalize: (str: string) => string;
+/**
+ * Returns the camelCase version of the given string.
+ */
+export declare const toCamelCase: (str: string) => string;
+/**
+ * Returns the PascalCase version of the given string.
+ */
+export declare const toPascalCase: (str: string) => string;
+/**
+ * Returns a pluralized version of the given string based on the count.
+ */
+export declare const pluralize: (s: string, count?: number) => string;
+/**
+ * Converts each line of a string to a commented line
+ */
+export declare const commentLines: (lines: string) => string;
+/**
+ * Provide all relevant conjugation of a name
+ */
+export declare const conjugateNames: (name: string) => {
+    PascalCase: string;
+    camelCase: string;
+    pluralized: string;
+    uncapitalizedPlural: string;
+};