@comet/admin-generator 8.0.0-beta.0

package/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2023, Vivid Planet Software GmbH
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/bin/admin-generator.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+require("ts-node").register({
+    require: ["tsconfig-paths/register"],
+});
+require("../lib/adminGenerator");

package/lib/adminGenerator.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/adminGenerator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const generate_command_1 = require("./commands/generate/generate-command");
+const program = new commander_1.Command();
+program.addCommand(generate_command_1.generateCommand);
+program.addHelpText("beforeAll", `⚠️️️⚠️️️⚠️️️  Admin Generator is still experimental and in beta phase. ⚠️️️⚠️️️⚠️️️ \n\n`);
+program.parse();

package/lib/commands/generate/generate-command.d.ts

@@ -0,0 +1,197 @@
+import { type GridColDef } from "@comet/admin";
+import { type IconName } from "@comet/admin-icons";
+import { type FinalFormFileUploadProps } from "@comet/cms-admin";
+import { type IconProps } from "@mui/material";
+import { type GridFilterItem, type GridSortDirection } from "@mui/x-data-grid";
+import { Command } from "commander";
+import { type GridCombinationColumnConfig } from "./generateGrid/combinationColumn";
+import { type UsableFields } from "./generateGrid/usableFields";
+import { type ColumnVisibleOption } from "./utils/columnVisibility";
+export type ImportReference = {
+    name: string;
+    import: string;
+};
+type IconObject = Pick<IconProps, "color" | "fontSize"> & {
+    name: IconName;
+};
+type Icon = IconName | IconObject | ImportReference;
+export type Adornment = string | {
+    icon: Icon;
+};
+type SingleFileFormFieldConfig = {
+    type: "fileUpload";
+    multiple?: false;
+    maxFiles?: 1;
+    download?: boolean;
+} & Pick<Partial<FinalFormFileUploadProps<false>>, "maxFileSize" | "readOnly" | "layout" | "accept">;
+type MultiFileFormFieldConfig = {
+    type: "fileUpload";
+    multiple: true;
+    maxFiles?: number;
+    download?: boolean;
+} & Pick<Partial<FinalFormFileUploadProps<true>>, "maxFileSize" | "readOnly" | "layout" | "accept">;
+type InputBaseFieldConfig = {
+    startAdornment?: Adornment;
+    endAdornment?: Adornment;
+};
+export type ComponentFormFieldConfig = {
+    type: "component";
+    component: ImportReference;
+};
+export type FormFieldConfig<T> = (({
+    type: "text";
+    multiline?: boolean;
+} & InputBaseFieldConfig) | ({
+    type: "number";
+} & InputBaseFieldConfig) | ({
+    type: "numberRange";
+    minValue: number;
+    maxValue: number;
+    disableSlider?: boolean;
+} & InputBaseFieldConfig) | {
+    type: "boolean";
+} | ({
+    type: "date";
+} & InputBaseFieldConfig) | ({
+    type: "dateTime";
+} & InputBaseFieldConfig) | ({
+    type: "staticSelect";
+    values?: Array<{
+        value: string;
+        label: string;
+    } | string>;
+    inputType?: "select" | "radio";
+} & Omit<InputBaseFieldConfig, "endAdornment">) | ({
+    type: "asyncSelect";
+    rootQuery: string;
+    labelField?: string;
+    filterField?: {
+        name: string;
+        gqlName?: string;
+    };
+} & Omit<InputBaseFieldConfig, "endAdornment">) | {
+    type: "block";
+    block: ImportReference;
+} | SingleFileFormFieldConfig | MultiFileFormFieldConfig) & {
+    name: keyof T;
+    label?: string;
+    required?: boolean;
+    virtual?: boolean;
+    validate?: ImportReference;
+    helperText?: string;
+    readOnly?: boolean;
+};
+export declare function isFormFieldConfig<T>(arg: any): arg is FormFieldConfig<T>;
+type OptionalNestedFieldsConfig<T> = {
+    type: "optionalNestedFields";
+    name: keyof T;
+    checkboxLabel?: string;
+    fields: FormFieldConfig<any>[];
+};
+export type FormLayoutConfig<T> = {
+    type: "fieldSet";
+    name: string;
+    title?: string;
+    supportText?: string;
+    collapsible?: boolean;
+    initiallyExpanded?: boolean;
+    fields: (FormFieldConfig<T> | OptionalNestedFieldsConfig<T> | ComponentFormFieldConfig)[];
+} | OptionalNestedFieldsConfig<T>;
+export declare function isFormLayoutConfig<T>(arg: any): arg is FormLayoutConfig<T>;
+export type FormConfig<T extends {
+    __typename?: string;
+}> = {
+    type: "form";
+    gqlType: T["__typename"];
+    mode?: "edit" | "add" | "all";
+    fragmentName?: string;
+    createMutation?: string;
+    fields: (FormFieldConfig<T> | FormLayoutConfig<T> | ComponentFormFieldConfig)[];
+};
+type TabsConfig = {
+    type: "tabs";
+    tabs: {
+        name: string;
+        content: GeneratorConfig;
+    }[];
+};
+export type BaseColumnConfig = Pick<GridColDef, "headerName" | "width" | "minWidth" | "maxWidth" | "flex" | "pinned" | "disableExport"> & {
+    headerInfoTooltip?: string;
+    visible?: ColumnVisibleOption;
+    fieldName?: string;
+};
+export type StaticSelectLabelCellContent = {
+    primaryText?: string;
+    secondaryText?: string;
+    icon?: Icon;
+};
+export type GridColumnConfig<T> = ({
+    type: "text";
+} | {
+    type: "number";
+} | {
+    type: "boolean";
+} | {
+    type: "date";
+} | {
+    type: "dateTime";
+} | {
+    type: "staticSelect";
+    values?: Array<{
+        value: string;
+        label: string | StaticSelectLabelCellContent;
+    } | string>;
+} | {
+    type: "block";
+    block: ImportReference;
+}) & {
+    name: UsableFields<T>;
+    filterOperators?: ImportReference;
+} & BaseColumnConfig;
+export type ActionsGridColumnConfig = {
+    type: "actions";
+    component?: ImportReference;
+} & BaseColumnConfig;
+type InitialFilterConfig = {
+    items: GridFilterItem[];
+    linkOperator?: "and" | "or";
+};
+export type GridConfig<T extends {
+    __typename?: string;
+}> = {
+    type: "grid";
+    gqlType: T["__typename"];
+    fragmentName?: string;
+    query?: string;
+    queryParamsPrefix?: string;
+    columns: Array<GridColumnConfig<T> | GridCombinationColumnConfig<UsableFields<T>> | ActionsGridColumnConfig>;
+    excelExport?: boolean;
+    add?: boolean;
+    edit?: boolean;
+    delete?: boolean;
+    copyPaste?: boolean;
+    readOnly?: boolean;
+    initialSort?: Array<{
+        field: string;
+        sort: GridSortDirection;
+    }>;
+    initialFilter?: InitialFilterConfig;
+    filterProp?: boolean;
+    toolbar?: boolean;
+    toolbarActionProp?: boolean;
+    newEntryText?: string;
+    rowActionProp?: boolean;
+    selectionProps?: "multiSelect" | "singleSelect";
+};
+export type GeneratorConfig = FormConfig<any> | GridConfig<any> | TabsConfig;
+type GQLDocumentConfig = {
+    document: string;
+    export: boolean;
+};
+export type GQLDocumentConfigMap = Record<string, GQLDocumentConfig>;
+export type GeneratorReturn = {
+    code: string;
+    gqlDocuments: GQLDocumentConfigMap;
+};
+export declare const generateCommand: Command;
+export {};

package/lib/commands/generate/generate-command.js

@@ -0,0 +1,114 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = exports.isFormLayoutConfig = exports.isFormFieldConfig = void 0;
+const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
+const load_1 = require("@graphql-tools/load");
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const glob_1 = require("glob");
+const graphql_1 = require("graphql");
+const path_1 = require("path");
+const generateForm_1 = require("./generateForm/generateForm");
+const generateGrid_1 = require("./generateGrid/generateGrid");
+const writeGenerated_1 = require("./utils/writeGenerated");
+// eslint-disable-next-line  @typescript-eslint/no-explicit-any
+function isFormFieldConfig(arg) {
+    return !isFormLayoutConfig(arg);
+}
+exports.isFormFieldConfig = isFormFieldConfig;
+// eslint-disable-next-line  @typescript-eslint/no-explicit-any
+function isFormLayoutConfig(arg) {
+    return arg.type !== undefined && ["fieldSet", "optionalNestedFields"].includes(arg.type);
+}
+exports.isFormLayoutConfig = isFormLayoutConfig;
+/**
+ * @experimental
+ */
+function runGenerate(filePattern = "src/**/*.cometGen.ts") {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const schema = yield (0, load_1.loadSchema)("./schema.gql", {
+            loaders: [new graphql_file_loader_1.GraphQLFileLoader()],
+        });
+        const gqlIntrospection = (0, graphql_1.introspectionFromSchema)(schema);
+        const files = yield (0, glob_1.glob)(filePattern);
+        for (const file of files) {
+            let outputCode = "";
+            let gqlDocumentsOutputCode = "";
+            const targetDirectory = `${(0, path_1.dirname)(file)}/generated`;
+            const baseOutputFilename = (0, path_1.basename)(file).replace(/\.cometGen\.ts$/, "");
+            const configs = yield (_a = `${process.cwd()}/${file.replace(/\.ts$/, "")}`, Promise.resolve().then(() => __importStar(require(_a))));
+            //const configs = await import(`${process.cwd()}/${file}`);
+            const codeOuputFilename = `${targetDirectory}/${(0, path_1.basename)(file.replace(/\.cometGen\.ts$/, ""))}.tsx`;
+            yield fs_1.promises.rm(codeOuputFilename, { force: true });
+            console.log(`generating ${file}`);
+            for (const exportName in configs) {
+                const config = configs[exportName];
+                let generated;
+                if (config.type == "form") {
+                    generated = (0, generateForm_1.generateForm)({ exportName, gqlIntrospection, baseOutputFilename, targetDirectory }, config);
+                }
+                else if (config.type == "grid") {
+                    generated = (0, generateGrid_1.generateGrid)({ exportName, gqlIntrospection, baseOutputFilename, targetDirectory }, config);
+                }
+                else {
+                    throw new Error(`Unknown config type: ${config.type}`);
+                }
+                outputCode += generated.code;
+                for (const queryName in generated.gqlDocuments) {
+                    const exportStatement = generated.gqlDocuments[queryName].export ? "export " : "";
+                    gqlDocumentsOutputCode += `${exportStatement} const ${queryName} = gql\`${generated.gqlDocuments[queryName].document}\`\n`;
+                }
+            }
+            yield (0, writeGenerated_1.writeGenerated)(codeOuputFilename, outputCode);
+            if (gqlDocumentsOutputCode != "") {
+                const gqlDocumentsOuputFilename = `${targetDirectory}/${(0, path_1.basename)(file.replace(/\.cometGen\.ts$/, ""))}.gql.tsx`;
+                yield fs_1.promises.rm(gqlDocumentsOuputFilename, { force: true });
+                gqlDocumentsOutputCode = `import { gql } from "@apollo/client";
+                import { finalFormFileUploadFragment, finalFormFileUploadDownloadableFragment } from "@comet/cms-admin";
+
+                ${gqlDocumentsOutputCode}
+            `;
+                yield (0, writeGenerated_1.writeGenerated)(gqlDocumentsOuputFilename, gqlDocumentsOutputCode);
+            }
+        }
+    });
+}
+exports.generateCommand = new commander_1.Command("generate")
+    .option("-f, --file <file>", "path to config file or glob pattern to generate specific files")
+    .action(({ file: filePattern }) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log("️️️⚠️️️⚠️️️⚠️️️  Admin Generator is still experimental and in beta phase.  ⚠️️️⚠️️️⚠️️️\n\n");
+    yield runGenerate(filePattern);
+}));

package/lib/commands/generate/generateForm/generateComponentFormField.d.ts

@@ -0,0 +1,5 @@
+import { type ComponentFormFieldConfig } from "../generate-command";
+import { type GenerateFieldsReturn } from "./generateFields";
+export declare function generateComponentFormField({ config }: {
+    config: ComponentFormFieldConfig;
+}): GenerateFieldsReturn;

package/lib/commands/generate/generateForm/generateComponentFormField.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponentFormField = void 0;
+function generateComponentFormField({ config }) {
+    const imports = [{ name: config.component.name, importPath: config.component.import }];
+    const code = `<${config.component.name} />`;
+    return {
+        imports,
+        hooksCode: "",
+        formFragmentFields: [],
+        formValueToGqlInputCode: "",
+        formValuesConfig: [],
+        finalFormConfig: undefined,
+        code,
+        gqlDocuments: {},
+    };
+}
+exports.generateComponentFormField = generateComponentFormField;

package/lib/commands/generate/generateForm/generateFields.d.ts

@@ -0,0 +1,35 @@
+import { type IntrospectionQuery } from "graphql";
+import { type FormConfig, type GeneratorReturn } from "../generate-command";
+import { type Imports } from "../utils/generateImportsCode";
+export type GenerateFieldsReturn = GeneratorReturn & {
+    imports: Imports;
+    hooksCode: string;
+    formFragmentFields: string[];
+    formValueToGqlInputCode: string;
+    formValuesConfig: {
+        omitFromFragmentType?: string;
+        destructFromFormValues?: string;
+        typeCode?: string;
+        initializationCode?: string;
+        defaultInitializationCode?: string;
+    }[];
+    finalFormConfig?: {
+        subscription?: {
+            values?: true;
+        };
+        renderProps?: {
+            values?: true;
+            form?: true;
+        };
+    };
+};
+export declare function findFieldByName(name: string, fields: FormConfig<any>["fields"]): FormConfig<any>["fields"][0] | undefined;
+export declare function generateFields({ gqlIntrospection, baseOutputFilename, fields, formFragmentName, formConfig, gqlType, namePrefix, }: {
+    gqlIntrospection: IntrospectionQuery;
+    baseOutputFilename: string;
+    fields: FormConfig<any>["fields"];
+    formConfig: FormConfig<any>;
+    formFragmentName: string;
+    gqlType: string;
+    namePrefix?: string;
+}): GenerateFieldsReturn;

package/lib/commands/generate/generateForm/generateFields.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFields = exports.findFieldByName = void 0;
+const generate_command_1 = require("../generate-command");
+const generateComponentFormField_1 = require("./generateComponentFormField");
+const generateFormField_1 = require("./generateFormField");
+const generateFormLayout_1 = require("./generateFormLayout");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function findFieldByName(name, fields) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return fields.reduce((acc, field) => {
+        return acc
+            ? acc
+            : "name" in field && field.name === name
+                ? field
+                : (0, generate_command_1.isFormLayoutConfig)(field)
+                    ? findFieldByName(name, field.fields)
+                    : undefined;
+    }, undefined);
+}
+exports.findFieldByName = findFieldByName;
+function generateFields({ gqlIntrospection, baseOutputFilename, fields, formFragmentName, formConfig, gqlType, namePrefix, }) {
+    const gqlDocuments = {};
+    let hooksCode = "";
+    let formValueToGqlInputCode = "";
+    const formFragmentFields = [];
+    const imports = [];
+    const formValuesConfig = [];
+    const finalFormConfig = { subscription: {}, renderProps: {} };
+    const code = fields
+        .map((field) => {
+        var _a, _b;
+        let generated;
+        if (field.type === "component") {
+            generated = (0, generateComponentFormField_1.generateComponentFormField)({
+                config: field,
+            });
+        }
+        else if ((0, generate_command_1.isFormFieldConfig)(field)) {
+            generated = (0, generateFormField_1.generateFormField)({
+                gqlIntrospection,
+                baseOutputFilename,
+                formFragmentName,
+                config: field,
+                formConfig,
+                gqlType,
+                namePrefix,
+            });
+        }
+        else if ((0, generate_command_1.isFormLayoutConfig)(field)) {
+            generated = (0, generateFormLayout_1.generateFormLayout)({
+                gqlIntrospection,
+                baseOutputFilename,
+                formFragmentName,
+                config: field,
+                formConfig,
+                gqlType,
+                namePrefix,
+            });
+        }
+        else {
+            throw new Error("Not supported config");
+        }
+        for (const name in generated.gqlDocuments) {
+            gqlDocuments[name] = generated.gqlDocuments[name];
+        }
+        imports.push(...generated.imports);
+        hooksCode += generated.hooksCode;
+        formValueToGqlInputCode += generated.formValueToGqlInputCode;
+        formFragmentFields.push(...generated.formFragmentFields);
+        formValuesConfig.push(...generated.formValuesConfig);
+        finalFormConfig.subscription = Object.assign(Object.assign({}, finalFormConfig.subscription), (_a = generated.finalFormConfig) === null || _a === void 0 ? void 0 : _a.subscription);
+        finalFormConfig.renderProps = Object.assign(Object.assign({}, finalFormConfig.renderProps), (_b = generated.finalFormConfig) === null || _b === void 0 ? void 0 : _b.renderProps);
+        return generated.code;
+    })
+        .join("\n");
+    return {
+        code,
+        hooksCode,
+        formValueToGqlInputCode,
+        formFragmentFields,
+        gqlDocuments,
+        imports,
+        formValuesConfig,
+        finalFormConfig,
+    };
+}
+exports.generateFields = generateFields;

package/lib/commands/generate/generateForm/generateForm.d.ts

@@ -0,0 +1,13 @@
+import { type IntrospectionQuery } from "graphql";
+import { type FormConfig, type GeneratorReturn } from "../generate-command";
+export type Prop = {
+    type: string;
+    optional: boolean;
+    name: string;
+};
+export declare function generateForm({ exportName, baseOutputFilename, targetDirectory, gqlIntrospection, }: {
+    exportName: string;
+    baseOutputFilename: string;
+    targetDirectory: string;
+    gqlIntrospection: IntrospectionQuery;
+}, config: FormConfig<any>): GeneratorReturn;