@comet/api-generator 8.0.0-beta.0

package/lib/commands/generate/utils/build-name-variants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classNameToInstanceName = classNameToInstanceName;
+exports.buildNameVariants = buildNameVariants;
+const pluralize_1 = require("pluralize");
+function classNameToInstanceName(className) {
+    return className[0].toLocaleLowerCase() + className.slice(1);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function buildNameVariants(metadata) {
+    const classNameSingular = metadata.className;
+    const classNamePlural = (0, pluralize_1.plural)(metadata.className);
+    const instanceNameSingular = classNameToInstanceName(classNameSingular);
+    const instanceNamePlural = classNameToInstanceName(classNamePlural);
+    const fileNameSingular = instanceNameSingular.replace(/[A-Z]/g, (i) => `-${i.toLocaleLowerCase()}`);
+    const fileNamePlural = instanceNamePlural.replace(/[A-Z]/g, (i) => `-${i.toLocaleLowerCase()}`);
+    return {
+        classNameSingular,
+        classNamePlural,
+        instanceNameSingular,
+        instanceNamePlural,
+        fileNameSingular,
+        fileNamePlural,
+    };
+}

package/lib/commands/generate/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const integerTypes: string[];

package/lib/commands/generate/utils/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integerTypes = void 0;
+exports.integerTypes = ["int", "integer", "tinyint", "smallint", "mediumint", "bigint", "int2", "int4", "int8", "serial"];

package/lib/commands/generate/utils/generate-imports-code.d.ts

@@ -0,0 +1,5 @@
+export type Imports = Array<{
+    name: string;
+    importPath: string;
+}>;
+export declare function generateImportsCode(imports: Imports): string;

package/lib/commands/generate/utils/generate-imports-code.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportsCode = generateImportsCode;
+// generate imports code and filter duplicates
+function generateImportsCode(imports) {
+    const importsNameToPath = new Map(); // name -> importPath
+    const filteredImports = imports.filter((imp) => {
+        if (importsNameToPath.has(imp.name)) {
+            if (importsNameToPath.get(imp.name) !== imp.importPath) {
+                throw new Error(`Duplicate import name ${imp.name}`);
+            }
+            else {
+                // duplicate import, skip
+                return false;
+            }
+        }
+        importsNameToPath.set(imp.name, imp.importPath);
+        return true;
+    });
+    const importsPathToName = {};
+    for (const imp of filteredImports) {
+        if (!importsPathToName[imp.importPath]) {
+            importsPathToName[imp.importPath] = [];
+        }
+        importsPathToName[imp.importPath].push(imp.name);
+    }
+    let importsString = "";
+    for (const [importPath, importNames] of Object.entries(importsPathToName)) {
+        importsString += `import { ${importNames.sort().join(", ")} } from "${importPath}";\n`;
+    }
+    return importsString;
+}

package/lib/commands/generate/utils/test-helper.d.ts

@@ -0,0 +1,5 @@
+import { type SourceFile } from "ts-morph";
+import { type GeneratedFile } from "./write-generated-files";
+export declare function formatSource(sourceCode: string): Promise<string>;
+export declare function formatGeneratedFiles(files: GeneratedFile[]): Promise<GeneratedFile[]>;
+export declare function parseSource(source: string): SourceFile;

package/lib/commands/generate/utils/test-helper.js

@@ -0,0 +1,72 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSource = formatSource;
+exports.formatGeneratedFiles = formatGeneratedFiles;
+exports.parseSource = parseSource;
+const process = __importStar(require("node:process"));
+const prettier_1 = require("prettier");
+const ts_morph_1 = require("ts-morph");
+let options;
+function formatSource(sourceCode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!options)
+            options = yield (0, prettier_1.resolveConfig)(process.cwd());
+        return (0, prettier_1.format)(sourceCode, Object.assign(Object.assign({}, options), { filepath: "test.ts" }));
+    });
+}
+function formatGeneratedFiles(files) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, file), { content: yield formatSource(file.content) });
+        })));
+    });
+}
+function parseSource(source) {
+    const project = new ts_morph_1.Project({
+        tsConfigFilePath: "./tsconfig.json",
+        skipAddingFilesFromTsConfig: true,
+    });
+    return project.createSourceFile("test.ts", source);
+}

package/lib/commands/generate/utils/ts-morph-helper.d.ts

@@ -0,0 +1,10 @@
+import { type EntityMetadata } from "@mikro-orm/postgresql";
+export declare function morphTsProperty(name: string, metadata: EntityMetadata<any>): import("ts-morph").PropertyDeclaration;
+export declare function findEnumName(propertyName: string, metadata: EntityMetadata<any>): string;
+export declare function findEnumImportPath(enumName: string, targetDirectory: string, metadata: EntityMetadata<any>): string;
+export declare function findValidatorImportPath(validatorName: string, generatorOptions: {
+    targetDirectory: string;
+}, metadata: EntityMetadata<any>): string;
+export declare function findBlockName(propertyName: string, metadata: EntityMetadata<any>): string;
+export declare function findBlockImportPath(blockName: string, targetDirectory: string, metadata: EntityMetadata<any>): string;
+export declare function findInputClassImportPath(className: string, targetDirectory: string, metadata: EntityMetadata<any>): string;

package/lib/commands/generate/utils/ts-morph-helper.js

@@ -0,0 +1,191 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.morphTsProperty = morphTsProperty;
+exports.findEnumName = findEnumName;
+exports.findEnumImportPath = findEnumImportPath;
+exports.findValidatorImportPath = findValidatorImportPath;
+exports.findBlockName = findBlockName;
+exports.findBlockImportPath = findBlockImportPath;
+exports.findInputClassImportPath = findInputClassImportPath;
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const project = new ts_morph_1.Project({
+    tsConfigFilePath: "tsconfig.json",
+    skipAddingFilesFromTsConfig: true,
+});
+function morphTsSource(metadata) {
+    let tsSource = project.getSourceFile(metadata.path);
+    if (!tsSource)
+        tsSource = project.addSourceFileAtPath(metadata.path);
+    return tsSource;
+}
+function morphTsClass(metadata) {
+    const tsSource = morphTsSource(metadata);
+    const tsClass = tsSource.getClass(metadata.className);
+    if (!tsClass)
+        throw new Error(`Class ${metadata.className} not found in ${metadata.path}`);
+    return tsClass;
+}
+function morphTsProperty(name, metadata) {
+    const tsClass = morphTsClass(metadata);
+    return tsClass.getPropertyOrThrow(name);
+}
+function findImportPath(importName, targetDirectory, metadata) {
+    var _a;
+    const tsSource = morphTsSource(metadata);
+    for (const tsImport of tsSource.getImportDeclarations()) {
+        for (const namedImport of tsImport.getNamedImports()) {
+            if (((_a = namedImport.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) == importName) {
+                throw new Error("Aliased enum import is not supported");
+            }
+            if (namedImport.getNameNode().getText() == importName) {
+                const importPath = tsImport.getModuleSpecifierValue();
+                const importSource = tsImport.getModuleSpecifierSourceFile();
+                if (!importSource) {
+                    throw new Error(`Can't resolve import ${importPath}`);
+                }
+                const exportedDeclarations = importSource.getExportedDeclarations().get(importName);
+                if (!exportedDeclarations)
+                    throw new Error(`Can't get exported declaration for ${importName}`);
+                const exportedDeclaration = exportedDeclarations[0];
+                if (importPath.startsWith("./") || importPath.startsWith("../")) {
+                    const absolutePath = path.resolve(path.dirname(metadata.path), importPath);
+                    return {
+                        importPath: path.relative(targetDirectory, absolutePath),
+                        exportedDeclaration,
+                    };
+                }
+                else {
+                    return { importPath, exportedDeclaration };
+                }
+            }
+        }
+    }
+    throw new Error(`${importName} import not found in ${metadata.path}`);
+}
+function findEnumName(propertyName, metadata) {
+    const tsProp = morphTsProperty(propertyName, metadata);
+    return tsProp
+        .getType()
+        .getText(tsProp)
+        .replace(/ ?\| ?undefined$/, "")
+        .replace(/\[\]$/, "");
+}
+function findEnumImportPath(enumName, targetDirectory, metadata) {
+    var _a;
+    const tsSource = morphTsSource(metadata);
+    if (tsSource.getEnum(enumName)) {
+        //enum defined in same file as entity
+        if (!((_a = tsSource.getEnum(enumName)) === null || _a === void 0 ? void 0 : _a.isExported())) {
+            throw new Error(`Enum ${enumName} is not exported in ${metadata.path}`);
+        }
+        return path.relative(targetDirectory, metadata.path).replace(/\.ts$/, "");
+    }
+    else {
+        //try to find import where enum is imported from
+        const { importPath } = findImportPath(enumName, targetDirectory, metadata);
+        return importPath;
+    }
+}
+function findValidatorImportPath(validatorName, generatorOptions, metadata) {
+    var _a, _b;
+    const tsSource = morphTsSource(metadata);
+    //validator defined in same file as entity
+    if (tsSource.getVariableDeclaration(validatorName) || tsSource.getFunction(validatorName)) {
+        if (!(((_a = tsSource.getVariableDeclaration(validatorName)) === null || _a === void 0 ? void 0 : _a.isExported()) || ((_b = tsSource.getFunction(validatorName)) === null || _b === void 0 ? void 0 : _b.isExported()))) {
+            throw new Error(`Validator ${validatorName} is not exported in ${metadata.path}`);
+        }
+        return path.relative(`${generatorOptions.targetDirectory}/dto`, metadata.path).replace(/\.ts$/, "");
+    }
+    else {
+        const { importPath } = findImportPath(validatorName, generatorOptions.targetDirectory, metadata);
+        return importPath;
+    }
+}
+function findBlockName(propertyName, metadata) {
+    const tsProp = morphTsProperty(propertyName, metadata);
+    if (!tsProp)
+        throw new Error("property not found");
+    const rootBlockDecorator = tsProp.getDecorators().find((i) => i.getName() == "RootBlock");
+    if (!rootBlockDecorator)
+        throw new Error(`RootBlock decorator not found for property ${propertyName}`);
+    return rootBlockDecorator.getArguments()[0].getText();
+}
+function findBlockImportPath(blockName, targetDirectory, metadata) {
+    var _a;
+    const tsSource = morphTsSource(metadata);
+    if (tsSource.getVariableDeclaration(blockName)) {
+        //block defined in same file as entity
+        if (!((_a = tsSource.getVariableDeclaration(blockName)) === null || _a === void 0 ? void 0 : _a.isExported())) {
+            throw new Error(`Block ${blockName} is not exported in ${metadata.path}`);
+        }
+        return path.relative(targetDirectory, metadata.path).replace(/\.ts$/, "");
+    }
+    else {
+        //try to find import where block is imported from
+        const { importPath } = findImportPath(blockName, targetDirectory, metadata);
+        return importPath;
+    }
+}
+function findInputClassImportPath(className, targetDirectory, metadata) {
+    var _a;
+    const tsSource = morphTsSource(metadata);
+    let returnImportPath;
+    let classDeclaration;
+    if (tsSource.getClass(className)) {
+        //block defined in same file as entity
+        if (!((_a = tsSource.getClass(className)) === null || _a === void 0 ? void 0 : _a.isExported())) {
+            throw new Error(`Class ${className} is not exported in ${metadata.path}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        classDeclaration = tsSource.getClass(className);
+        returnImportPath = path.relative(targetDirectory, metadata.path).replace(/\.ts$/, "");
+    }
+    else {
+        //try to find import where block is imported from
+        const { importPath, exportedDeclaration } = findImportPath(className, targetDirectory, metadata);
+        if (!(exportedDeclaration instanceof ts_morph_1.ClassDeclaration)) {
+            throw new Error(`Exported declaration for ${className} is not a class`);
+        }
+        classDeclaration = exportedDeclaration;
+        returnImportPath = importPath;
+    }
+    if (!classDeclaration.getDecorators().some((i) => i.getName() == "InputType")) {
+        throw new Error(`Exported declaration for ${className} is not decorated with @InputType`);
+    }
+    return returnImportPath;
+}

package/lib/commands/generate/utils/write-generated-file.d.ts

@@ -0,0 +1 @@
+export declare function writeGeneratedFile(filePath: string, contents: string): Promise<void>;

package/lib/commands/generate/utils/write-generated-file.js

@@ -0,0 +1,69 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeGeneratedFile = writeGeneratedFile;
+const eslint_1 = require("eslint");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+function writeGeneratedFile(filePath, contents) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const header = `// This file has been generated by comet api-generator.
+    // You may choose to use this file as scaffold by moving this file out of generated folder and removing this comment.
+    `;
+        yield fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+        yield fs_1.promises.writeFile(filePath, contents);
+        const eslint = new eslint_1.ESLint({
+            cwd: process.cwd(),
+            fix: true,
+        });
+        const lintResult = yield eslint.lintText(header + contents, {
+            filePath,
+        });
+        const output = lintResult[0] && lintResult[0].output ? lintResult[0].output : lintResult[0].source;
+        if (output) {
+            yield fs_1.promises.writeFile(filePath, output);
+        }
+        console.log(`generated ${filePath}`);
+    });
+}

package/lib/commands/generate/utils/write-generated-files.d.ts

@@ -0,0 +1,8 @@
+export interface GeneratedFile {
+    name: string;
+    content: string;
+    type: "resolver" | "input" | "filter" | "sort" | "service" | "args";
+}
+export declare function writeGeneratedFiles(files: GeneratedFile[], options: {
+    targetDirectory: string;
+}): Promise<void>;

package/lib/commands/generate/utils/write-generated-files.js

@@ -0,0 +1,20 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeGeneratedFiles = writeGeneratedFiles;
+const write_generated_file_1 = require("./write-generated-file");
+function writeGeneratedFiles(files, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const file of files) {
+            yield (0, write_generated_file_1.writeGeneratedFile)(`${options.targetDirectory}/${file.name}`, file.content);
+        }
+    });
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@comet/api-generator",
+  "version": "8.0.0-beta.0",
+  "repository": {
+    "directory": "packages/api/api-generator",
+    "type": "git",
+    "url": "https://github.com/vivid-planet/comet"
+  },
+  "license": "BSD-2-Clause",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "bin": {
+    "comet-api-generator": "bin/api-generator.js"
+  },
+  "files": [
+    "bin/**/*.js",
+    "lib/*"
+  ],
+  "dependencies": {
+    "commander": "^9.5.0",
+    "pluralize": "^8.0.0",
+    "ts-morph": "^25.0.1",
+    "ts-node": "^10.9.2",
+    "@comet/cms-api": "8.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@mikro-orm/cli": "^6.4.5",
+    "@mikro-orm/postgresql": "^6.4.5",
+    "@nestjs/graphql": "^13.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.4",
+    "@types/pluralize": "^0.0.33",
+    "class-validator": "^0.14.1",
+    "eslint": "^9.20.1",
+    "jest": "^29.7.0",
+    "npm-run-all2": "^5.0.2",
+    "prettier": "^3.5.1",
+    "reflect-metadata": "^0.2.2",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.3",
+    "uuid": "^11.0.5",
+    "@comet/eslint-config": "8.0.0-beta.0"
+  },
+  "peerDependencies": {
+    "@mikro-orm/cli": "^6.0.0",
+    "@nestjs/graphql": "^13.0.0",
+    "class-validator": "^0.14.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "$npm_execpath run clean && tsc -p tsconfig.build.json",
+    "clean": "rimraf lib",
+    "dev": "tsc --watch --preserveWatchOutput -p tsconfig.build.json",
+    "lint": "run-p lint:prettier lint:eslint lint:tsc",
+    "lint:eslint": "eslint --max-warnings 0 src/ **/*.json --no-warn-ignored",
+    "lint:prettier": "npx prettier --check './**/*.{js,json,md,yml,yaml}'",
+    "lint:tsc": "tsc",
+    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
+    "test:watch": "jest --watch"
+  }
+}