@comet/api-generator 8.0.0-beta.0

package/lib/commands/generate/generateCrudInput/generate-crud-input.d.ts

@@ -0,0 +1,11 @@
+import { type EntityMetadata } from "@mikro-orm/postgresql";
+import { type GeneratedFile } from "../utils/write-generated-files";
+export declare function generateCrudInput(generatorOptions: {
+    targetDirectory: string;
+}, metadata: EntityMetadata<any>, options?: {
+    nested: boolean;
+    fileName?: string;
+    className?: string;
+    excludeFields: string[];
+    generateUpdateInput?: boolean;
+}): Promise<GeneratedFile[]>;

package/lib/commands/generate/generateCrudInput/generate-crud-input.js

@@ -0,0 +1,463 @@
+"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.generateCrudInput = generateCrudInput;
+const cms_api_1 = require("@comet/cms-api");
+const class_validator_1 = require("class-validator");
+const generate_crud_1 = require("../generateCrud/generate-crud");
+const build_name_variants_1 = require("../utils/build-name-variants");
+const constants_1 = require("../utils/constants");
+const generate_imports_code_1 = require("../utils/generate-imports-code");
+const ts_morph_helper_1 = require("../utils/ts-morph-helper");
+function tsCodeRecordToString(object) {
+    const filteredEntries = Object.entries(object).filter(([key, value]) => value !== undefined);
+    if (filteredEntries.length == 0)
+        return "";
+    return `{${filteredEntries.map(([key, value]) => `${key}: ${value},`).join("\n")}}`;
+}
+function findReferenceTargetType(targetMeta, referencedColumnName) {
+    const referencedColumnProp = targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.props.find((p) => p.name == referencedColumnName);
+    if (!referencedColumnProp)
+        throw new Error("referencedColumnProp not found");
+    if (referencedColumnProp.type == "uuid") {
+        return "uuid";
+    }
+    else if (referencedColumnProp.type == "string") {
+        return "string";
+    }
+    else if (referencedColumnProp.type == "integer" || referencedColumnProp.type == "int") {
+        return "integer";
+    }
+    else {
+        return null;
+    }
+}
+function generateCrudInput(generatorOptions_1, metadata_1) {
+    return __awaiter(this, arguments, void 0, function* (generatorOptions, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    metadata, options = {
+        nested: false,
+        excludeFields: [],
+        generateUpdateInput: true,
+    }) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const generatedFiles = [];
+        const { dedicatedResolverArgProps } = (0, generate_crud_1.buildOptions)(metadata, generatorOptions);
+        const props = metadata.props
+            .filter((prop) => {
+            return !prop.embedded;
+        })
+            .filter((prop) => {
+            return (0, cms_api_1.hasCrudFieldFeature)(metadata.class, prop.name, "input");
+        })
+            .filter((prop) => {
+            //filter out props that are dedicatedResolverArgProps
+            return !dedicatedResolverArgProps.some((dedicatedResolverArgProp) => dedicatedResolverArgProp.name === prop.name);
+        })
+            .filter((prop) => !options.excludeFields.includes(prop.name));
+        let fieldsOut = "";
+        const imports = [
+            { name: "IsSlug", importPath: "@comet/cms-api" },
+            { name: "RootBlockInputScalar", importPath: "@comet/cms-api" },
+            { name: "IsNullable", importPath: "@comet/cms-api" },
+            { name: "PartialType", importPath: "@comet/cms-api" },
+            { name: "BlockInputInterface", importPath: "@comet/cms-api" },
+            { name: "isBlockInputInterface", importPath: "@comet/cms-api" },
+        ];
+        for (const prop of props) {
+            let type = prop.type;
+            const fieldName = prop.name;
+            const definedDecorators = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getDecorators();
+            const decorators = [];
+            let isOptional = prop.nullable;
+            if (prop.name != "position") {
+                if (!prop.nullable) {
+                    decorators.push("@IsNotEmpty()");
+                }
+                else {
+                    decorators.push("@IsNullable()");
+                }
+            }
+            if (["id", "createdAt", "updatedAt", "scope"].includes(prop.name)) {
+                //skip those (TODO find a non-magic solution?)
+                continue;
+            }
+            else if (prop.name == "position") {
+                const initializer = (_a = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _a === void 0 ? void 0 : _a.getText();
+                const defaultValue = initializer == "undefined" || initializer == "null" ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: "true", defaultValue });
+                isOptional = true;
+                decorators.push(`@IsOptional()`);
+                decorators.push(`@Min(1)`);
+                decorators.push("@IsInt()");
+                decorators.push(`@Field(() => Int, ${fieldOptions})`);
+                type = "number";
+            }
+            else if (prop.enum) {
+                const initializer = (_b = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _b === void 0 ? void 0 : _b.getText();
+                const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined) ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: prop.nullable ? "true" : undefined, defaultValue });
+                const enumName = (0, ts_morph_helper_1.findEnumName)(prop.name, metadata);
+                const importPath = (0, ts_morph_helper_1.findEnumImportPath)(enumName, `${generatorOptions.targetDirectory}/dto`, metadata);
+                imports.push({ name: enumName, importPath });
+                decorators.push(`@IsEnum(${enumName})`);
+                decorators.push(`@Field(() => ${enumName}, ${fieldOptions})`);
+                type = enumName;
+            }
+            else if (prop.type === "EnumArrayType") {
+                if (prop.nullable) {
+                    console.warn(`${prop.name}: Nullable enum arrays are not supported`);
+                }
+                decorators.length = 0; //remove @IsNotEmpty
+                const initializer = (_c = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _c === void 0 ? void 0 : _c.getText();
+                const fieldOptions = tsCodeRecordToString({ defaultValue: initializer });
+                const enumName = (0, ts_morph_helper_1.findEnumName)(prop.name, metadata);
+                const importPath = (0, ts_morph_helper_1.findEnumImportPath)(enumName, `${generatorOptions.targetDirectory}/dto`, metadata);
+                imports.push({ name: enumName, importPath });
+                decorators.push(`@IsEnum(${enumName}, { each: true })`);
+                decorators.push(`@Field(() => [${enumName}], ${fieldOptions})`);
+                type = `${enumName}[]`;
+            }
+            else if (prop.type === "string" || prop.type === "text") {
+                const initializer = (_d = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _d === void 0 ? void 0 : _d.getText();
+                const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined) ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: prop.nullable ? "true" : undefined, defaultValue });
+                decorators.push("@IsString()");
+                if (prop.name.startsWith("scope_")) {
+                    continue;
+                }
+                else if (prop.name === "slug") {
+                    //TODO find a non-magic solution
+                    decorators.push("@IsSlug()");
+                }
+                decorators.push(`@Field(${fieldOptions})`);
+                type = "string";
+            }
+            else if (prop.type === "DecimalType" || prop.type == "BigIntType" || prop.type === "number") {
+                const initializer = (_e = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _e === void 0 ? void 0 : _e.getText();
+                const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined) ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: prop.nullable ? "true" : undefined, defaultValue });
+                if (constants_1.integerTypes.includes(prop.columnTypes[0])) {
+                    decorators.push("@IsInt()");
+                    decorators.push(`@Field(() => Int, ${fieldOptions})`);
+                }
+                else {
+                    decorators.push("@IsNumber()");
+                    decorators.push(`@Field(${fieldOptions})`);
+                }
+                type = "number";
+            }
+            else if (prop.type === "DateType") {
+                // ISO Date without time
+                const initializer = (_f = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _f === void 0 ? void 0 : _f.getText();
+                const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined) ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: prop.nullable ? "true" : undefined, defaultValue });
+                decorators.push("@IsDate()");
+                decorators.push(`@Field(() => GraphQLDate, ${fieldOptions})`);
+                type = "Date";
+            }
+            else if (prop.type === "Date") {
+                // DateTime
+                const initializer = (_g = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _g === void 0 ? void 0 : _g.getText();
+                const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined) ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: prop.nullable ? "true" : undefined, defaultValue });
+                decorators.push("@IsDate()");
+                decorators.push(`@Field(${fieldOptions})`);
+                type = "Date";
+            }
+            else if (prop.type === "BooleanType" || prop.type === "boolean") {
+                const initializer = (_h = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _h === void 0 ? void 0 : _h.getText();
+                const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined) ? "null" : initializer;
+                const fieldOptions = tsCodeRecordToString({ nullable: prop.nullable ? "true" : undefined, defaultValue });
+                decorators.push("@IsBoolean()");
+                decorators.push(`@Field(${fieldOptions})`);
+                type = "boolean";
+            }
+            else if (prop.type === "RootBlockType") {
+                const blockName = (0, ts_morph_helper_1.findBlockName)(prop.name, metadata);
+                const importPath = (0, ts_morph_helper_1.findBlockImportPath)(blockName, `${generatorOptions.targetDirectory}/dto`, metadata);
+                imports.push({ name: blockName, importPath });
+                decorators.push(`@Field(() => RootBlockInputScalar(${blockName})${prop.nullable ? ", { nullable: true }" : ""})`);
+                decorators.push(`@Transform(({ value }) => (isBlockInputInterface(value) ? value : ${blockName}.blockInputFactory(value)), { toClassOnly: true })`);
+                decorators.push("@ValidateNested()");
+                type = "BlockInputInterface";
+            }
+            else if (prop.kind == "m:1") {
+                const initializer = (_j = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _j === void 0 ? void 0 : _j.getText();
+                const defaultValueNull = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined);
+                const fieldOptions = tsCodeRecordToString({
+                    nullable: prop.nullable ? "true" : undefined,
+                    defaultValue: defaultValueNull ? "null" : undefined,
+                });
+                decorators.push(`@Field(() => ID, ${fieldOptions})`);
+                if (prop.referencedColumnNames.length > 1) {
+                    console.warn(`${prop.name}: Composite keys are not supported`);
+                    continue;
+                }
+                const refType = findReferenceTargetType(prop.targetMeta, prop.referencedColumnNames[0]);
+                if (refType == "uuid") {
+                    type = "string";
+                    decorators.push("@IsUUID()");
+                }
+                else if (refType == "string") {
+                    type = "string";
+                    decorators.push("@IsString()");
+                }
+                else if (refType == "integer") {
+                    type = "number";
+                    decorators.push("@Transform(({ value }) => (value ? parseInt(value) : null))");
+                    decorators.push("@IsInt()");
+                }
+                else {
+                    console.warn(`${prop.name}: Unsupported referenced type`);
+                }
+            }
+            else if (prop.kind == "1:m") {
+                if (prop.orphanRemoval) {
+                    //if orphanRemoval is enabled, we need to generate a nested input type
+                    decorators.length = 0;
+                    if (!prop.targetMeta)
+                        throw new Error("No targetMeta");
+                    const inputNameClassName = `${metadata.className}Nested${prop.targetMeta.className}Input`;
+                    {
+                        const excludeFields = prop.targetMeta.props.filter((p) => p.kind == "m:1" && p.targetMeta == metadata).map((p) => p.name);
+                        const { fileNameSingular } = (0, build_name_variants_1.buildNameVariants)(metadata);
+                        const { fileNameSingular: targetFileNameSingular } = (0, build_name_variants_1.buildNameVariants)(prop.targetMeta);
+                        const fileName = `dto/${fileNameSingular}-nested-${targetFileNameSingular}.input.ts`;
+                        const nestedInputFiles = yield generateCrudInput(generatorOptions, prop.targetMeta, {
+                            nested: true,
+                            fileName,
+                            className: inputNameClassName,
+                            excludeFields,
+                        });
+                        generatedFiles.push(...nestedInputFiles);
+                        imports.push({
+                            name: inputNameClassName,
+                            importPath: nestedInputFiles[0].name.replace(/^dto/, ".").replace(/\.ts$/, ""),
+                        });
+                    }
+                    decorators.push(`@Field(() => [${inputNameClassName}], {${prop.nullable ? "nullable: true" : "defaultValue: []"}})`);
+                    decorators.push(`@IsArray()`);
+                    decorators.push(`@Type(() => ${inputNameClassName})`);
+                    type = `${inputNameClassName}[]`;
+                }
+                else {
+                    //if orphanRemoval is disabled, we reference the id in input
+                    decorators.length = 0;
+                    decorators.push(`@Field(() => [ID], {${prop.nullable ? "nullable: true" : "defaultValue: []"}})`);
+                    decorators.push(`@IsArray()`);
+                    if (prop.referencedColumnNames.length > 1) {
+                        console.warn(`${prop.name}: Composite keys are not supported`);
+                        continue;
+                    }
+                    const refType = findReferenceTargetType(prop.targetMeta, prop.referencedColumnNames[0]);
+                    if (refType == "uuid") {
+                        type = "string[]";
+                        decorators.push("@IsUUID(undefined, { each: true })");
+                    }
+                    else if (refType == "string") {
+                        type = "string[]";
+                        decorators.push("@IsString({ each: true })");
+                    }
+                    else if (refType == "integer") {
+                        type = "number[]";
+                        decorators.push("@Transform(({ value }) => value.map((id: string) => parseInt(id)))");
+                        decorators.push("@IsInt({ each: true })");
+                    }
+                    else {
+                        console.warn(`${prop.name}: Unsupported referenced type`);
+                    }
+                }
+            }
+            else if (prop.kind == "m:n") {
+                decorators.length = 0;
+                decorators.push(`@Field(() => [ID], {${prop.nullable ? "nullable" : "defaultValue: []"}})`);
+                decorators.push(`@IsArray()`);
+                if (prop.referencedColumnNames.length > 1) {
+                    console.warn(`${prop.name}: Composite keys are not supported`);
+                    continue;
+                }
+                const refType = findReferenceTargetType(prop.targetMeta, prop.referencedColumnNames[0]);
+                if (refType == "uuid") {
+                    type = "string[]";
+                    decorators.push("@IsUUID(undefined, { each: true })");
+                }
+                else if (refType == "string") {
+                    type = "string[]";
+                    decorators.push("@IsString({ each: true })");
+                }
+                else if (refType == "integer") {
+                    type = "number[]";
+                    decorators.push("@Transform(({ value }) => value.map((id: string) => parseInt(id)))");
+                }
+                else {
+                    console.warn(`${prop.name}: Unsupported referenced type`);
+                }
+            }
+            else if (prop.kind == "1:1") {
+                if (!prop.targetMeta)
+                    throw new Error("No targetMeta");
+                const inputNameClassName = `${metadata.className}Nested${prop.targetMeta.className}Input`;
+                {
+                    const excludeFields = prop.targetMeta.props.filter((p) => p.kind == "1:1" && p.targetMeta == metadata).map((p) => p.name);
+                    const { fileNameSingular } = (0, build_name_variants_1.buildNameVariants)(metadata);
+                    const { fileNameSingular: targetFileNameSingular } = (0, build_name_variants_1.buildNameVariants)(prop.targetMeta);
+                    const fileName = `dto/${fileNameSingular}-nested-${targetFileNameSingular}.input.ts`;
+                    const nestedInputFiles = yield generateCrudInput(generatorOptions, prop.targetMeta, {
+                        nested: true,
+                        fileName,
+                        className: inputNameClassName,
+                        excludeFields,
+                    });
+                    generatedFiles.push(...nestedInputFiles);
+                    imports.push({
+                        name: inputNameClassName,
+                        importPath: nestedInputFiles[nestedInputFiles.length - 1].name.replace(/^dto/, ".").replace(/\.ts$/, ""),
+                    });
+                }
+                decorators.push(`@Field(() => ${inputNameClassName}${prop.nullable ? ", { nullable: true }" : ""})`);
+                decorators.push(`@Type(() => ${inputNameClassName})`);
+                decorators.push("@ValidateNested()");
+                type = `${inputNameClassName}`;
+            }
+            else if (prop.type == "JsonType" || prop.embeddable || prop.type == "ArrayType") {
+                const tsProp = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata);
+                let tsType = tsProp.getType();
+                if (tsType.isUnion() && tsType.getUnionTypes().length == 2 && tsType.getUnionTypes()[0].getText() == "undefined") {
+                    // undefinded | type (or prop?: type) -> type
+                    tsType = tsType.getUnionTypes()[1];
+                }
+                type = tsType.getText(tsProp);
+                if (tsType.isArray()) {
+                    const initializer = (_k = tsProp.getInitializer()) === null || _k === void 0 ? void 0 : _k.getText();
+                    const defaultValue = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined)
+                        ? "null"
+                        : initializer == "[]"
+                            ? "[]"
+                            : undefined;
+                    const fieldOptions = tsCodeRecordToString({
+                        nullable: prop.nullable ? "true" : undefined,
+                        defaultValue: defaultValue,
+                    });
+                    decorators.push(`@IsArray()`);
+                    if (type == "string[]") {
+                        decorators.push(`@Field(() => [String], ${fieldOptions})`);
+                        decorators.push("@IsString({ each: true })");
+                    }
+                    else if (type == "number[]") {
+                        decorators.push(`@Field(() => [Number], ${fieldOptions})`);
+                        decorators.push("@IsNumber({ each: true })");
+                    }
+                    else if (type == "boolean[]") {
+                        decorators.push(`@Field(() => [Boolean], ${fieldOptions})`);
+                        decorators.push("@IsBoolean({ each: true })");
+                    }
+                    else if (tsType.getArrayElementTypeOrThrow().isClass()) {
+                        const nestedClassName = tsType.getArrayElementTypeOrThrow().getText(tsProp);
+                        const importPath = (0, ts_morph_helper_1.findInputClassImportPath)(nestedClassName, `${generatorOptions.targetDirectory}/dto`, metadata);
+                        imports.push({ name: nestedClassName, importPath });
+                        decorators.push(`@ValidateNested()`);
+                        decorators.push(`@Type(() => ${nestedClassName})`);
+                        decorators.push(`@Field(() => [${nestedClassName}], ${fieldOptions})`);
+                    }
+                    else {
+                        decorators.push(`@Field(() => [GraphQLJSONObject], ${fieldOptions}) // Warning: this input is not validated properly`);
+                    }
+                }
+                else if (tsType.isClass()) {
+                    const nestedClassName = tsType.getText(tsProp);
+                    const importPath = (0, ts_morph_helper_1.findInputClassImportPath)(nestedClassName, `${generatorOptions.targetDirectory}/dto`, metadata);
+                    imports.push({ name: nestedClassName, importPath });
+                    decorators.push(`@ValidateNested()`);
+                    decorators.push(`@Type(() => ${nestedClassName})`);
+                    decorators.push(`@Field(() => ${nestedClassName}${prop.nullable ? ", { nullable: true }" : ""})`);
+                }
+                else {
+                    decorators.push(`@Field(() => GraphQLJSONObject${prop.nullable ? ", { nullable: true }" : ""}) // Warning: this input is not validated properly`);
+                }
+            }
+            else if (prop.type == "uuid") {
+                const initializer = (_l = (0, ts_morph_helper_1.morphTsProperty)(prop.name, metadata).getInitializer()) === null || _l === void 0 ? void 0 : _l.getText();
+                const defaultValueNull = prop.nullable && (initializer == "undefined" || initializer == "null" || initializer === undefined);
+                const fieldOptions = tsCodeRecordToString({
+                    nullable: prop.nullable ? "true" : undefined,
+                    defaultValue: defaultValueNull ? "null" : undefined,
+                });
+                decorators.push(`@Field(() => ID, ${fieldOptions})`);
+                decorators.push("@IsUUID()");
+                type = "string";
+            }
+            else {
+                console.warn(`${prop.name}: unsupported type ${type}`);
+                continue;
+            }
+            const classValidatorValidators = (0, class_validator_1.getMetadataStorage)().getTargetValidationMetadatas(metadata.class, prop.name, false, false, undefined);
+            for (const validator of classValidatorValidators) {
+                if (validator.propertyName !== prop.name)
+                    continue;
+                const constraints = (0, class_validator_1.getMetadataStorage)().getTargetValidatorConstraints(validator.constraintCls);
+                for (const constraint of constraints) {
+                    const decorator = definedDecorators.find((decorator) => {
+                        return (
+                        // ignore casing since class validator is inconsistent with casing
+                        decorator.getName().toUpperCase() === constraint.name.toUpperCase() ||
+                            // some class validator decorators have a prefix "Is" but not in the constraint name
+                            `Is${decorator.getName()}`.toUpperCase() === constraint.name.toUpperCase());
+                    });
+                    if (decorator) {
+                        const importPath = (0, ts_morph_helper_1.findValidatorImportPath)(decorator.getName(), generatorOptions, metadata);
+                        if (importPath) {
+                            imports.push({ name: decorator.getName(), importPath });
+                            if (!decorators.includes(decorator.getText())) {
+                                decorators.unshift(decorator.getText());
+                            }
+                        }
+                    }
+                    else {
+                        console.warn(`Decorator import for constraint ${constraint.name} not found`);
+                    }
+                }
+            }
+            fieldsOut += `${decorators.join("\n")}
+    ${fieldName}${isOptional ? "?" : ""}: ${type};
+    
+    `;
+        }
+        const className = (_m = options.className) !== null && _m !== void 0 ? _m : `${metadata.className}Input`;
+        const inputOut = `import { Field, InputType, ID, Int } from "@nestjs/graphql";
+import { Transform, Type } from "class-transformer";
+import { IsString, IsNotEmpty, ValidateNested, IsNumber, IsBoolean, IsDate, IsOptional, IsEnum, IsUUID, IsArray, IsInt, Min } from "class-validator";
+import { GraphQLJSONObject } from "graphql-scalars";
+import { GraphQLDate } from "graphql-scalars";
+${(0, generate_imports_code_1.generateImportsCode)(imports)}
+
+@InputType()
+export class ${className} {
+    ${fieldsOut}
+}
+
+${options.generateUpdateInput && !options.nested
+            ? `
+@InputType()
+export class ${className.replace(/Input$/, "")}UpdateInput extends PartialType(${className}) {}
+`
+            : ""}
+`;
+        const { fileNameSingular } = (0, build_name_variants_1.buildNameVariants)(metadata);
+        const fileName = (_o = options.fileName) !== null && _o !== void 0 ? _o : `dto/${fileNameSingular}.input.ts`;
+        generatedFiles.push({
+            name: fileName,
+            content: inputOut,
+            type: "input",
+        });
+        return generatedFiles;
+    });
+}

package/lib/commands/generate/generateCrudSingle/generate-crud-single.d.ts

@@ -0,0 +1,4 @@
+import { type CrudSingleGeneratorOptions } from "@comet/cms-api";
+import { type EntityMetadata } from "@mikro-orm/postgresql";
+import { type GeneratedFile } from "../utils/write-generated-files";
+export declare function generateCrudSingle(generatorOptions: CrudSingleGeneratorOptions, metadata: EntityMetadata<any>): Promise<GeneratedFile[]>;

package/lib/commands/generate/generateCrudSingle/generate-crud-single.js

@@ -0,0 +1,153 @@
+"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.generateCrudSingle = generateCrudSingle;
+const cms_api_1 = require("@comet/cms-api");
+const path = __importStar(require("path"));
+const generate_crud_input_1 = require("../generateCrudInput/generate-crud-input");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function generateCrudSingle(generatorOptions, metadata) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const classNameSingular = metadata.className;
+        const classNamePlural = !metadata.className.endsWith("s") ? `${metadata.className}s` : metadata.className;
+        const instanceNameSingular = classNameSingular[0].toLocaleLowerCase() + classNameSingular.slice(1);
+        const instanceNamePlural = classNamePlural[0].toLocaleLowerCase() + classNamePlural.slice(1);
+        const fileNameSingular = instanceNameSingular.replace(/[A-Z]/g, (i) => `-${i.toLocaleLowerCase()}`);
+        const fileNamePlural = instanceNamePlural.replace(/[A-Z]/g, (i) => `-${i.toLocaleLowerCase()}`);
+        if (!generatorOptions.requiredPermission)
+            generatorOptions.requiredPermission = [instanceNamePlural];
+        function generateCrudResolver() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const generatedFiles = [];
+                const scopeProp = metadata.props.find((prop) => prop.name == "scope");
+                if (scopeProp && !scopeProp.targetMeta)
+                    throw new Error("Scope prop has no targetMeta");
+                const blockProps = metadata.props.filter((prop) => {
+                    return (0, cms_api_1.hasCrudFieldFeature)(metadata.class, prop.name, "input") && prop.type === "RootBlockType";
+                });
+                const serviceOut = `import { ObjectQuery } from "@mikro-orm/postgresql";
+    import { InjectRepository } from "@mikro-orm/nestjs";
+    import { EntityRepository } from "@mikro-orm/postgresql";
+    import { Injectable } from "@nestjs/common";
+    import { ${metadata.className} } from "${path.relative(generatorOptions.targetDirectory, metadata.path).replace(/\.ts$/, "")}";
+    
+    @Injectable()
+    export class ${classNamePlural}Service {    
+        
+    }
+    `;
+                generatedFiles.push({ name: `${fileNamePlural}.service.ts`, content: serviceOut, type: "service" });
+                const resolverOut = `import { InjectRepository } from "@mikro-orm/nestjs";
+    import { EntityRepository, EntityManager } from "@mikro-orm/postgresql";
+    import { FindOptions } from "@mikro-orm/postgresql";
+    import { Args, ID, Mutation, Query, Resolver } from "@nestjs/graphql";
+    import { RequiredPermission, SortDirection, validateNotModified } from "@comet/cms-api";
+    
+    import { ${metadata.className} } from "${path.relative(generatorOptions.targetDirectory, metadata.path).replace(/\.ts$/, "")}";
+    ${scopeProp && scopeProp.targetMeta
+                    ? `import { ${scopeProp.targetMeta.className} } from "${path
+                        .relative(generatorOptions.targetDirectory, scopeProp.targetMeta.path)
+                        .replace(/\.ts$/, "")}";`
+                    : ""}
+    import { ${classNamePlural}Service } from "./${fileNamePlural}.service";
+    import { ${classNameSingular}Input } from "./dto/${fileNameSingular}.input";
+    import { Paginated${classNamePlural} } from "./dto/paginated-${fileNamePlural}";
+
+    @Resolver(() => ${metadata.className})
+    @RequiredPermission(${JSON.stringify(generatorOptions.requiredPermission)}${!scopeProp ? `, { skipScopeCheck: true }` : ""})
+    export class ${classNameSingular}Resolver {
+        constructor(
+            private readonly entityManager: EntityManager,
+            private readonly ${instanceNamePlural}Service: ${classNamePlural}Service,
+            @InjectRepository(${metadata.className}) private readonly repository: EntityRepository<${metadata.className}>
+        ) {}
+    
+        @Query(() => ${metadata.className}, { nullable: true })
+        async ${instanceNameSingular}(
+                ${scopeProp ? `@Args("scope", { type: () => ${scopeProp.type} }) scope: ${scopeProp.type},` : ""}
+            ): Promise<${metadata.className} | null> {
+            const ${instanceNamePlural} = await this.repository.find({${scopeProp ? `scope` : ""}});
+            if (${instanceNamePlural}.length > 1) {
+                throw new Error("There must be only one ${instanceNameSingular}");
+            }
+    
+            return ${instanceNamePlural}.length > 0 ? ${instanceNamePlural}[0] : null;
+        }
+    
+        @Mutation(() => ${metadata.className})
+        async save${classNameSingular}(
+            ${scopeProp ? `@Args("scope", { type: () => ${scopeProp.type} }) scope: ${scopeProp.type},` : ""}
+            @Args("input", { type: () => ${classNameSingular}Input }) input: ${classNameSingular}Input
+        ): Promise<${metadata.className}> {
+            let ${instanceNameSingular} = await this.repository.findOne({${scopeProp ? `scope` : ""}});
+
+            if (!${instanceNameSingular}) {
+                ${instanceNameSingular} = this.repository.create({ 
+                    ...input,
+                    ${blockProps.length ? `${blockProps.map((prop) => `${prop.name}: input.${prop.name}.transformToBlockData()`).join(", ")}, ` : ""}
+                    ${scopeProp ? `scope,` : ""} 
+                });
+            }
+
+            ${instanceNameSingular}.assign({
+                ...input,
+                ${blockProps.length ? `${blockProps.map((prop) => `${prop.name}: input.${prop.name}.transformToBlockData()`).join(", ")}, ` : ""}
+            });
+    
+            await this.entityManager.flush();
+    
+            return ${instanceNameSingular};
+        }
+    }
+    `;
+                generatedFiles.push({ name: `${fileNameSingular}.resolver.ts`, content: resolverOut, type: "resolver" });
+                return generatedFiles;
+            });
+        }
+        return [
+            ...(yield (0, generate_crud_input_1.generateCrudInput)(generatorOptions, metadata, { nested: false, excludeFields: [], generateUpdateInput: false })),
+            ...(yield generateCrudResolver()),
+        ];
+    });
+}

package/lib/commands/generate/utils/build-name-variants.d.ts

@@ -0,0 +1,10 @@
+import { type EntityMetadata } from "@mikro-orm/postgresql";
+export declare function classNameToInstanceName(className: string): string;
+export declare function buildNameVariants(metadata: EntityMetadata<any>): {
+    classNameSingular: string;
+    classNamePlural: string;
+    instanceNameSingular: string;
+    instanceNamePlural: string;
+    fileNameSingular: string;
+    fileNamePlural: string;
+};