@postxl/generator 0.0.1

package/dist/src/generators/models/stub.generator.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStub = void 0;
+const assert_never_1 = __importDefault(require("assert-never"));
+const meta_1 = require("../../lib/meta");
+const fields_1 = require("../../lib/schema/fields");
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates a stub definition file for a given model.
+ */
+function generateStub({ model, meta }) {
+    const { fields } = model;
+    const imports = imports_1.ImportsGenerator.from(meta.data.stubFilePath).addImport({
+        items: [model.typeName, meta.types.toBrandedIdTypeFnName],
+        from: meta.types.importPath,
+    });
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        const depMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
+        imports.addImport({
+            items: [relation.relationToModel.typeName, depMeta.types.toBrandedIdTypeFnName],
+            from: meta.types.importPath,
+        });
+    }
+    return `
+${imports.generate()}
+
+/**
+ * Utility object containing default values for all fields in a model.
+ */
+export const ${meta.data.defaultStubConstantName}: ${model.typeName} = {
+	${getAssigmentStatementModel({ fields })}
+}
+
+/**
+ * Utility function that creates a new ${meta.userFriendlyName} object from a partial object of values.
+ */
+export const ${meta.data.stubGenerationFnName} = (
+	item: Partial<${model.typeName}>
+): ${model.typeName} => ({
+  ...${meta.data.defaultStubConstantName},
+  ...item,
+})
+`;
+}
+exports.generateStub = generateStub;
+/**
+ * Return an assignment statement for a model where each field is assigned null or its type's default value.
+ */
+function getAssigmentStatementModel({ fields }) {
+    return fields
+        .map((f) => {
+        if (!f.isRequired) {
+            return `${f.name}: null`;
+        }
+        switch (f.kind) {
+            case 'scalar':
+                return `${f.name}: ${(0, fields_1.getDefaultValueForType)(f.typeName)}`;
+            case 'id':
+                const idRefMeta = (0, meta_1.getModelMetadata)({ model: f.model });
+                return `${f.name}: ${idRefMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
+            case 'relation':
+                const refModelMeta = (0, meta_1.getModelMetadata)({ model: f.relationToModel });
+                return `${f.name}: ${refModelMeta.types.toBrandedIdTypeFnName}(${(0, fields_1.getDefaultValueForType)(f.unbrandedTypeName)})`;
+            case 'enum':
+                return `${f.name}: "${f.enumerator.values[0]}"`;
+            default:
+                (0, assert_never_1.default)(f);
+        }
+    })
+        .join(',\n');
+}

package/dist/src/generators/models/types.generator.d.ts

@@ -0,0 +1,9 @@
+import { ModelMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates types for a given model.
+ */
+export declare function generateModelTypes({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

package/dist/src/generators/models/types.generator.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelTypes = void 0;
+const assert_never_1 = __importDefault(require("assert-never"));
+const meta_1 = require("../../lib/meta");
+const fields_1 = require("../../lib/schema/fields");
+const zod_1 = require("../../lib/schema/zod");
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates types for a given model.
+ */
+function generateModelTypes({ model, meta }) {
+    const idField = model.idField;
+    const imports = imports_1.ImportsGenerator.from(meta.types.filePath);
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        if (relation.relationToModel.typeName === model.typeName) {
+            continue;
+        }
+        const refModel = relation.relationToModel;
+        const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+        imports.addImport({
+            items: [refMeta.types.toBrandedIdTypeFnName, refModel.brandedIdType],
+            from: refMeta.types.filePath,
+        });
+    }
+    for (const f of (0, fields_1.getEnumFields)(model)) {
+        const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
+        imports.addImport({
+            items: [f.enumerator.typeName],
+            from: refEnumMeta.types.filePath,
+        });
+    }
+    return `
+import { z } from 'zod'
+
+${imports.generate()}
+
+
+${model.description
+        ? `
+/**
+ * ${model.description.split('\n').join('\n * ')} 
+ */`
+        : ''}
+export type ${model.typeName} = { 
+  ${model.fields
+        .map((f) => `
+${getFieldComment(f)}
+${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}`)
+        .join('\n')}
+}
+
+/**
+ * Branded Id type that should be used to identify an instance of this model.
+ */
+export type ${model.brandedIdType} = ${idField.unbrandedTypeName} & {
+  readonly is${model.typeName}: unique symbol
+}
+
+/**
+ * Converts a given scalar to a branded id type. 
+ */
+export function ${meta.types.toBrandedIdTypeFnName}(id: ${idField.unbrandedTypeName}): ${model.brandedIdType} {
+  return id as ${model.brandedIdType}
+}
+
+/**
+ * Zod decoder for validating a Participant object.
+ */
+export const ${meta.types.zodDecoderFnName} = z.object({
+  ${model.fields.map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`).join(',')}
+})
+
+`;
+}
+exports.generateModelTypes = generateModelTypes;
+function getFieldComment(f) {
+    const examples = getFieldExamples(f);
+    let comment = '';
+    if (f.description) {
+        comment = ` * ${f.description.split('\n').join('\n * ')}\n`;
+    }
+    if (examples) {
+        comment += ` * ${examples}\n`;
+    }
+    if (comment === '')
+        return '';
+    return `
+/**
+${comment}*/`;
+}
+function getFieldExamples(f) {
+    if (!f.attributes.examples)
+        return undefined;
+    return `Examples: ${f.attributes.examples.map((e) => `"${e}"`).join(', ')}`;
+}
+/**
+ * Converts a field to a TypeScript type definition.
+ */
+function getFieldType(f) {
+    switch (f.kind) {
+        case 'enum':
+            return f.typeName;
+        case 'relation':
+            return f.relationToModel.brandedIdType;
+        case 'id':
+            return f.model.brandedIdType;
+        case 'scalar':
+            return f.typeName;
+        default:
+            (0, assert_never_1.default)(f);
+    }
+}

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

@@ -0,0 +1,43 @@
+export type AttributeValue = unknown;
+export type Attributes = Record<string, AttributeValue>;
+export type ModelAttributes = {
+    /**
+     * Schema tag: ´@@Ignore()`
+     */
+    ignore: boolean;
+    /**
+     * Schema tag: ´@@SkipUpdate()`
+     */
+    skipUpdate: boolean;
+    /**
+     * Schema tag: ´@@SkipCreate()`
+     */
+    skipCreate: boolean;
+    /**
+     * Schema tag: ´@@SkipDelete()`
+     */
+    skipDelete: boolean;
+    /**
+     * Schema tag: ´@@Description("Description of the model")`
+     */
+    description?: string;
+};
+export type FieldAttributes = {
+    /**
+     * Schema tag: ´@@Ignore()`
+     */
+    ignore: boolean;
+    /**
+     * Schema tag: ´@@Description("Description of the field")`
+     */
+    description?: string;
+    /**
+     * Schema tag: ´@@Examples("Example1", "Example2")`
+     */
+    examples?: unknown[];
+    /**
+     * Schema tag: ´@@DefaultField()`
+     * The property of the model that identifies the default row.
+     */
+    isDefaultField?: boolean;
+};

package/dist/src/lib/attributes.js

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

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

@@ -0,0 +1,26 @@
+import * as Types from './schema/types';
+/**
+ * A utility component that lets you generate TypeScript export statements that export all items from a given file.
+ */
+export declare class ExportsGenerator {
+    private _exports;
+    /**
+     * Path of the file we're generating exports for.
+     */
+    private _path;
+    constructor({ path }: {
+        path: string;
+    });
+    /**
+     * Creates a new instance of the exports generator.
+     */
+    static from(path: Types.Path): ExportsGenerator;
+    /**
+     * Adds a given file to the collection of files we're exporting everything from.
+     */
+    exportEverythingFrom(from: Types.Path): ExportsGenerator;
+    /**
+     * Returns the TypeScript export statements.
+     */
+    generate(): string;
+}

package/dist/src/lib/exports.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportsGenerator = void 0;
+const file_1 = require("./utils/file");
+/**
+ * A utility component that lets you generate TypeScript export statements that export all items from a given file.
+ */
+class ExportsGenerator {
+    constructor({ path }) {
+        this._path = path;
+        this._exports = new Set();
+    }
+    /**
+     * Creates a new instance of the exports generator.
+     */
+    static from(path) {
+        return new ExportsGenerator({ path });
+    }
+    /**
+     * Adds a given file to the collection of files we're exporting everything from.
+     */
+    exportEverythingFrom(from) {
+        const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
+        this._exports.add(resolvedPath);
+        return this;
+    }
+    /**
+     * Returns the TypeScript export statements.
+     */
+    generate() {
+        const stetements = [...this._exports.values()]
+            .sort((a, b) => a.localeCompare(b))
+            .map((path) => `export * from '${path}'`)
+            .join('\n');
+        return stetements;
+    }
+}
+exports.ExportsGenerator = ExportsGenerator;

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

@@ -0,0 +1,35 @@
+import * as Types from './schema/types';
+/**
+ * A utility component that lets you generate TypeScript import statements
+ * and makes sure every import is only added once.
+ */
+export declare class ImportsGenerator {
+    /**
+     * Lists of values and types we import from a given path indexed by the path.
+     */
+    private _imports;
+    /**
+     * Path of the file we're generating imports for.
+     */
+    private _path;
+    constructor({ path }: {
+        path: string;
+    });
+    /**
+     * Creates a new instance of the imports generator.
+     */
+    static from(path: Types.Path): ImportsGenerator;
+    /**
+     * Adds a given import statement to the imports list.
+     *
+     * NOTE: You should never add no items from a given path.
+     */
+    addImport({ items, from, }: {
+        items: (Types.Function | Types.ClassName | Types.TypeName | Types.VariableName)[];
+        from: Types.Path;
+    }): ImportsGenerator;
+    /**
+     * Returns the TypeScript import statement.
+     */
+    generate(): string;
+}

package/dist/src/lib/imports.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportsGenerator = void 0;
+const file_1 = require("./utils/file");
+/**
+ * A utility component that lets you generate TypeScript import statements
+ * and makes sure every import is only added once.
+ */
+class ImportsGenerator {
+    constructor({ path }) {
+        /**
+         * Lists of values and types we import from a given path indexed by the path.
+         */
+        this._imports = {};
+        this._path = path;
+    }
+    /**
+     * Creates a new instance of the imports generator.
+     */
+    static from(path) {
+        return new ImportsGenerator({ path });
+    }
+    /**
+     * Adds a given import statement to the imports list.
+     *
+     * NOTE: You should never add no items from a given path.
+     */
+    addImport({ items, from, }) {
+        // NOTE: Generator relies that there's at least one import statement from a given path.
+        if (items.length === 0) {
+            throw new Error(`You cannot add an import statement without any items from ${from}.`);
+        }
+        const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
+        if (!this._imports[resolvedPath]) {
+            this._imports[resolvedPath] = new Set();
+        }
+        items.forEach((item) => this._imports[resolvedPath].add(item));
+        return this;
+    }
+    /**
+     * Returns the TypeScript import statement.
+     */
+    generate() {
+        const stetements = Object.entries(this._imports)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([path, items]) => {
+            const alphabeticallySortedItems = Array.from(items).sort((a, b) => a.localeCompare(b));
+            // NOTE: You cannot remove imports and we check that there's at least one imported item for every path.
+            return `import { ${alphabeticallySortedItems.join(', ')} } from '${path}'`;
+        })
+            .join('\n');
+        return stetements;
+    }
+}
+exports.ImportsGenerator = ImportsGenerator;