@postxl/generator 0.0.1

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conjugateNames = exports.commentLines = exports.pluralize = exports.toPascalCase = exports.toCamelCase = exports.uncapitalize = void 0;
+/**
+ * Returns the same string with a lowercase first letter.
+ */
+const uncapitalize = (str) => {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+};
+exports.uncapitalize = uncapitalize;
+/**
+ * Returns the camelCase version of the given string.
+ */
+const toCamelCase = (str) => {
+    // If the string is already in camelCase format, return it unchanged
+    if (/^[a-z][a-zA-Z]*$/.test(str)) {
+        return str;
+    }
+    // Split the string into an array of words
+    const words = str.split(/[\s_-]+/);
+    // Convert the first word to lowercase and capitalize the rest
+    const camelCasedWords = words.map((word, index) => (index === 0 ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1));
+    // Join the words back together into a single string
+    const camelCasedStr = camelCasedWords.join('');
+    return camelCasedStr;
+};
+exports.toCamelCase = toCamelCase;
+/**
+ * Returns the PascalCase version of the given string.
+ */
+const toPascalCase = (str) => {
+    const s = (0, exports.toCamelCase)(str);
+    return s.charAt(0).toUpperCase() + s.slice(1);
+};
+exports.toPascalCase = toPascalCase;
+/**
+ * Returns a pluralized version of the given string based on the count.
+ */
+const pluralize = (s, count = 2) => {
+    if (count === 1)
+        return s;
+    if (s.endsWith('y') &&
+        !s.endsWith('ay') &&
+        !s.endsWith('ey') &&
+        !s.endsWith('iy') &&
+        !s.endsWith('oy') &&
+        !s.endsWith('uy')) {
+        return s.slice(0, -1) + 'ies';
+    }
+    if (s.endsWith('s')) {
+        return s;
+    }
+    return s + 's';
+};
+exports.pluralize = pluralize;
+/**
+ * Converts each line of a string to a commented line
+ */
+const commentLines = (lines) => {
+    return lines
+        .split('\n')
+        .map((l) => `// ${l}`)
+        .join('\n');
+};
+exports.commentLines = commentLines;
+/**
+ * Provide all relevant conjugation of a name
+ */
+const conjugateNames = (name) => ({
+    PascalCase: (0, exports.toPascalCase)(name),
+    camelCase: (0, exports.toCamelCase)(name),
+    pluralized: (0, exports.pluralize)(name),
+    uncapitalizedPlural: (0, exports.uncapitalize)((0, exports.pluralize)(name)),
+});
+exports.conjugateNames = conjugateNames;

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

@@ -0,0 +1,12 @@
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+export type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+export type Exact<T, I> = T extends I ? (Exclude<keyof T, keyof I> extends never ? T : never) : never;
+export type UncapitalizeObjectKeys<T> = {
+    [key in keyof T as Uncapitalize<key & string>]: T[key];
+};
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+};
+export {};

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

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

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

@@ -0,0 +1,137 @@
+import * as prettier from 'prettier';
+type FileWriteError = 'EIP' | 'EISDIR';
+type FileReadError = 'ENF' | 'EISDIR';
+type FileStatus = 'UNCHANGED' | 'WRITTEN' | 'SKIPPED';
+/**
+ * A utility class that helps you manage a collection of files.
+ */
+export declare class VirtualFS {
+    /**
+     * Human readable messages for file write errors.
+     */
+    static WRITE_ERROR_MESSAGES: {
+        [Key in FileWriteError]: string;
+    };
+    /**
+     * Human readable messages for file read errors.
+     */
+    static READ_ERROR_MESSAGES: {
+        [Key in FileReadError]: string;
+    };
+    private _files;
+    constructor(files?: {
+        [key: string]: string;
+    });
+    /**
+     * Returns the chunks of the resolved path.
+     */
+    private _parse;
+    /**
+     * Writes the given contents to the given path. Path should be a relative path from the root
+     * of the virtual file system with no special characters.
+     */
+    write(path: string, content: string): {
+        ok: true;
+    } | {
+        ok: false;
+        path: string;
+        err: FileWriteError;
+    };
+    /**
+     * Appends given content to the file at a given path if it exists.
+     */
+    append(path: string, content: string): {
+        ok: true;
+    } | {
+        ok: false;
+        path: string;
+        err: FileWriteError | FileReadError;
+    };
+    /**
+     * Copies given files to the given path.
+     */
+    copy(files: VirtualFS, path: string): void;
+    /**
+     * Lists all files and folders in the given path.
+     */
+    list(path: string): {
+        kind: 'FILE' | 'FOLDER';
+        name: string;
+    }[];
+    /**
+     * Returns a dictionary of all files in the virtual file system indexed by their paths.
+     */
+    files(): {
+        [path: string]: string;
+    };
+    /**
+     * Lets you read the contents of a file in the given path.
+     */
+    read(path: string): {
+        ok: true;
+        content: string;
+    } | {
+        ok: false;
+        path: string;
+        err: FileReadError;
+    };
+    /**
+     * Writes files to the given path, overriding managed files and ignoring
+     * detached files (i.e. files that don't have a checksum value).
+     *
+     * Returns a list of paths that were written.
+     */
+    flush(relativeOutPath: string, force?: boolean): Promise<{
+        status: FileStatus;
+        path: string;
+    }[]>;
+    /**
+     * Writes the contents of the file to a given path. If there's already a file there,
+     * it checks the checksum and overrides it if the content hasn't changed.
+     *
+     * Returns `true` if the file was written, `false` if it wasn't.
+     */
+    private _safeWriteUTF8File;
+    /**
+     * Tries to read a file at a given path and surpresses the error if it fails to do so.
+     */
+    private _safeReadUTF8File;
+    private static CHECKSUM_PREFIX;
+    private static META_PREFIX;
+    /**
+     * Returns the checksum of the given content, ignoring
+     * the line containing the checksum if present.
+     */
+    private _calculateContentChecksum;
+    /**
+     * Adds the checksum indicator to the given content.
+     */
+    private _appendChecksumToContent;
+    /**
+     * Adds arbitrary meta information to the given content.
+     *
+     * NOTE: This only changes when the content changes regardless of the change of the meta value.
+     */
+    private _appendMetaToContent;
+    /**
+     * Extracts the checksum from the given content.
+     */
+    private _extractChecksumFromContent;
+    /**
+     * Creates a new file system from the given directory.
+     */
+    static fromDirectory(cwd: string): Promise<VirtualFS>;
+    /**
+     * Walks the file tree, calling the given function for each file.
+     */
+    walk(fn: (path: string, content: string) => void): void;
+    /**
+     * Transforms files in the file system.
+     */
+    transform(fn: (path: string, content: string) => string): void;
+    /**
+     * Formats the file system using configuration in the given directory.
+     */
+    format(options?: prettier.Options | null): void;
+}
+export {};

package/dist/src/lib/vfs.js

@@ -0,0 +1,419 @@
+"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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualFS = void 0;
+const crypto = __importStar(require("crypto"));
+const prettier = __importStar(require("prettier"));
+const nodepath = __importStar(require("path"));
+const nodefs = __importStar(require("fs"));
+const util_1 = require("util");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const error_1 = require("./utils/error");
+const mkdir = (0, util_1.promisify)(nodefs.mkdir);
+const writefile = (0, util_1.promisify)(nodefs.writeFile);
+const readfile = (0, util_1.promisify)(nodefs.readFile);
+/**
+ * A utility class that helps you manage a collection of files.
+ */
+class VirtualFS {
+    constructor(files) {
+        this._files = { kind: 'FOLDER', children: {} };
+        if (files) {
+            for (const path in files) {
+                this.write(path, files[path]);
+            }
+        }
+    }
+    /**
+     * Returns the chunks of the resolved path.
+     */
+    _parse(path) {
+        const parts = path.split('/');
+        if (parts.length === 0) {
+            return [];
+        }
+        // Remove the first empty string if the path starts with a slash.
+        if (parts[0] === '' || parts[0] === '.') {
+            parts.shift();
+        }
+        const resolved = [];
+        while (parts.length > 0) {
+            const part = parts.shift();
+            if (part === '..') {
+                resolved.pop();
+                continue;
+            }
+            if (part === '.') {
+                continue;
+            }
+            if (part === '' && parts.length > 0) {
+                console.warn(`Empty subpath in path: ${path}`);
+                continue;
+            }
+            resolved.push(part);
+        }
+        return resolved;
+    }
+    /**
+     * Writes the given contents to the given path. Path should be a relative path from the root
+     * of the virtual file system with no special characters.
+     */
+    write(path, content) {
+        const parts = this._parse(path);
+        let folder = parts.shift();
+        let cwd = this._files;
+        while (folder != null) {
+            // We reached a file along the while descending the system.
+            if (cwd.kind === 'FILE') {
+                return { ok: false, path, err: 'EISDIR' };
+            }
+            if (cwd.kind === 'FOLDER') {
+                // We found the folder where the file should be created.
+                if (parts.length === 0 && folder !== '') {
+                    cwd.children[folder] = { kind: 'FILE', content };
+                    return { ok: true };
+                }
+                // Folder doesn't exist yet.
+                if (cwd.children[folder] == null) {
+                    cwd.children[folder] = { kind: 'FOLDER', children: {} };
+                }
+                cwd = cwd.children[folder];
+                folder = parts.shift();
+                continue;
+            }
+            return { ok: false, path, err: 'EIP' };
+        }
+        return { ok: false, path, err: 'EIP' };
+    }
+    /**
+     * Appends given content to the file at a given path if it exists.
+     */
+    append(path, content) {
+        const existing = this.read(path);
+        if (!existing.ok) {
+            return existing;
+        }
+        return this.write(path, existing.content + '\n' + content);
+    }
+    /**
+     * Copies given files to the given path.
+     */
+    copy(files, path) {
+        walk(files._files, path, (path, content) => this.write(path, content));
+    }
+    /**
+     * Lists all files and folders in the given path.
+     */
+    list(path) {
+        const parts = this._parse(path);
+        let folder = parts.shift();
+        let cwd = this._files;
+        // Descend the tree until we reach the folder we want to list.
+        while (folder != null) {
+            // It's possible that the path ends with a slash.
+            if (folder === '' && parts.length === 0) {
+                break;
+            }
+            if (cwd.kind === 'FOLDER' && cwd.children.hasOwnProperty(folder)) {
+                cwd = cwd.children[folder];
+                folder = parts.shift();
+                continue;
+            }
+            return [];
+        }
+        // List items.
+        const items = [];
+        if (cwd.kind === 'FOLDER') {
+            for (const [name, child] of Object.entries(cwd.children)) {
+                items.push({ kind: child.kind, name });
+            }
+        }
+        return items;
+    }
+    /**
+     * Returns a dictionary of all files in the virtual file system indexed by their paths.
+     */
+    files() {
+        const fs = {};
+        walk(this._files, '/', (path, content) => {
+            fs[path] = content;
+        });
+        return fs;
+    }
+    /**
+     * Lets you read the contents of a file in the given path.
+     */
+    read(path) {
+        const parts = this._parse(path);
+        let folder = parts.shift();
+        let cwd = this._files;
+        while (folder != null) {
+            if (cwd.kind === 'FOLDER' && cwd.children.hasOwnProperty(folder)) {
+                cwd = cwd.children[folder];
+                folder = parts.shift();
+                continue;
+            }
+            return { ok: false, path, err: 'ENF' };
+        }
+        if (cwd.kind === 'FILE' && parts.length === 0) {
+            return { ok: true, content: cwd.content };
+        }
+        return { ok: false, path, err: 'ENF' };
+    }
+    /**
+     * Writes files to the given path, overriding managed files and ignoring
+     * detached files (i.e. files that don't have a checksum value).
+     *
+     * Returns a list of paths that were written.
+     */
+    flush(relativeOutPath, force = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetdir = nodepath.resolve(relativeOutPath);
+            const tasks = Object.entries(this.files()).map(([path, content]) => __awaiter(this, void 0, void 0, function* () {
+                const fullPath = nodepath.join(targetdir, path);
+                const status = yield this._safeWriteUTF8File({ target: fullPath, content, force });
+                return { path, status };
+            }));
+            const entries = yield Promise.all(tasks);
+            return entries;
+        });
+    }
+    /**
+     * Writes the contents of the file to a given path. If there's already a file there,
+     * it checks the checksum and overrides it if the content hasn't changed.
+     *
+     * Returns `true` if the file was written, `false` if it wasn't.
+     */
+    _safeWriteUTF8File({ target, content, force, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dir = nodepath.dirname(target);
+            yield mkdir(dir, { recursive: true });
+            const checksum = this._calculateContentChecksum(content);
+            let status = 'WRITTEN';
+            const currentFileContent = yield this._safeReadUTF8File(target);
+            if (currentFileContent != null) {
+                // NOTE: If the content of the file hasn't changed, then the calculated checksum
+                // should match the one that's currently in the file.
+                const currentChecksum = this._extractChecksumFromContent(currentFileContent);
+                const expectedChecksum = this._calculateContentChecksum(currentFileContent);
+                if (currentChecksum !== expectedChecksum) {
+                    status = 'SKIPPED';
+                }
+                else if (currentChecksum === checksum) {
+                    // NOTE: We only check the checksum. It's possible that the content of the file changed
+                    // in a way that doesn't affect the checksum (e.g. empty lines and spaces).
+                    status = 'UNCHANGED';
+                }
+            }
+            // We manually override the status if the `force` flag is set.
+            if (force) {
+                status = 'WRITTEN';
+            }
+            if (status === 'WRITTEN') {
+                const contentWithDate = this._appendMetaToContent(content, `date: ${new Date().toISOString()}`);
+                const contentWithChecksum = this._appendChecksumToContent(contentWithDate);
+                yield writefile(target, contentWithChecksum, { encoding: 'utf-8' });
+            }
+            return status;
+        });
+    }
+    /**
+     * Tries to read a file at a given path and surpresses the error if it fails to do so.
+     */
+    _safeReadUTF8File(target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const content = yield readfile(target, { encoding: 'utf-8' });
+                return content;
+            }
+            catch (err) {
+                return null;
+            }
+        });
+    }
+    /**
+     * Returns the checksum of the given content, ignoring
+     * the line containing the checksum if present.
+     */
+    _calculateContentChecksum(content) {
+        const lines = content.split('\n');
+        // Take the content and return SHA checksum
+        const hash = crypto.createHash('sha256', {});
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (lines.length === 0 || line.startsWith(VirtualFS.CHECKSUM_PREFIX) || line.startsWith(VirtualFS.META_PREFIX)) {
+                continue;
+            }
+            hash.update(line);
+        }
+        return hash.digest('hex');
+    }
+    /**
+     * Adds the checksum indicator to the given content.
+     */
+    _appendChecksumToContent(content) {
+        const checksum = this._calculateContentChecksum(content);
+        return content + '\n' + VirtualFS.CHECKSUM_PREFIX + checksum;
+    }
+    /**
+     * Adds arbitrary meta information to the given content.
+     *
+     * NOTE: This only changes when the content changes regardless of the change of the meta value.
+     */
+    _appendMetaToContent(content, meta) {
+        return content + '\n' + VirtualFS.META_PREFIX + meta;
+    }
+    /**
+     * Extracts the checksum from the given content.
+     */
+    _extractChecksumFromContent(content) {
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(VirtualFS.CHECKSUM_PREFIX)) {
+                return lines[i].replace(VirtualFS.CHECKSUM_PREFIX, '');
+            }
+        }
+        return null;
+    }
+    /**
+     * Creates a new file system from the given directory.
+     */
+    static fromDirectory(cwd) {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const fs = new VirtualFS();
+            const entries = fast_glob_1.default.stream('**/*', { cwd, dot: true, onlyFiles: true });
+            try {
+                for (var _d = true, entries_1 = __asyncValues(entries), entries_1_1; entries_1_1 = yield entries_1.next(), _a = entries_1_1.done, !_a;) {
+                    _c = entries_1_1.value;
+                    _d = false;
+                    try {
+                        const entry = _c;
+                        const content = yield readfile(nodepath.join(cwd, entry.toString()), { encoding: 'utf-8' });
+                        fs.write(entry.toString(), content);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = entries_1.return)) yield _b.call(entries_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return fs;
+        });
+    }
+    /**
+     * Walks the file tree, calling the given function for each file.
+     */
+    walk(fn) {
+        walk(this._files, '/', fn);
+    }
+    /**
+     * Transforms files in the file system.
+     */
+    transform(fn) {
+        this.walk((path, content) => {
+            this.write(path, fn(path, content));
+        });
+    }
+    /**
+     * Formats the file system using configuration in the given directory.
+     */
+    format(options = null) {
+        this.transform((path, content) => {
+            const ext = nodepath.extname(path);
+            let parser = undefined;
+            if (ext === '.js' || ext === '.jsx') {
+                parser = 'babel';
+            }
+            if (ext === '.ts' || ext === '.tsx') {
+                parser = 'typescript';
+            }
+            try {
+                return prettier.format(content, Object.assign(Object.assign({}, options), { parser }));
+            }
+            catch (err) {
+                (0, error_1.throwError)(`
+          ${content}\n\n
+          Failed to format ${path}\n\n`);
+            }
+        });
+    }
+}
+/**
+ * Human readable messages for file write errors.
+ */
+VirtualFS.WRITE_ERROR_MESSAGES = {
+    EIP: 'Invalid path',
+    EISDIR: 'Is a directory',
+};
+/**
+ * Human readable messages for file read errors.
+ */
+VirtualFS.READ_ERROR_MESSAGES = {
+    ENF: 'No such file or directory',
+    EISDIR: 'Is a directory',
+};
+// We add a collection of random strings that will never appear in the code otherwise.
+VirtualFS.CHECKSUM_PREFIX = `// PostXL checksum (#@!):`;
+VirtualFS.META_PREFIX = `// PostXL meta (#@!) `;
+exports.VirtualFS = VirtualFS;
+// MARK: - Utilities
+/**
+ * Walks the file tree, calling the given function for each file, prepending the starting path.
+ */
+function walk(tree, path, fn) {
+    if (tree.kind === 'FILE') {
+        fn(path, tree.content);
+        return;
+    }
+    for (const [name, child] of Object.entries(tree.children)) {
+        walk(child, nodepath.join(path, name), fn);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { DMMF } from '@prisma/generator-helper';
+import type { Attributes, AttributeValue, FieldAttributes, ModelAttributes } from '../lib/attributes';
+/**
+ * Parses attributes from a given string using provided prefix.
+ */
+export declare function parseAttributesFromDocumentation({ documentation }: {
+    documentation?: string;
+}): Attributes;
+export declare function parseArgumentToStringOrStringArray(str: string): AttributeValue;
+/**
+ * Returns attribute information for a given model.
+ */
+export declare function getModelAttributes(model: DMMF.Model): ModelAttributes;
+/**
+ * Returns all attributes assigned to a field
+ */
+export declare function getFieldAttributes(field: DMMF.Field): FieldAttributes;