@comet/admin-generator 8.0.0-beta.0

package/lib/commands/generate/generateGrid/generateGridToolbar.d.ts

@@ -0,0 +1,14 @@
+type Options = {
+    componentName: string;
+    forwardToolbarAction: boolean | undefined;
+    hasSearch: boolean;
+    hasFilter: boolean;
+    excelExport: boolean | undefined;
+    allowAdding: boolean;
+    instanceGqlType: string;
+    gqlType: string;
+    newEntryText: string | undefined;
+    fragmentName: string;
+};
+export declare const generateGridToolbar: ({ componentName, forwardToolbarAction, hasSearch, hasFilter, excelExport, allowAdding, instanceGqlType, gqlType, newEntryText, fragmentName, }: Options) => string;
+export {};

package/lib/commands/generate/generateGrid/generateGridToolbar.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGridToolbar = void 0;
+const change_case_1 = require("change-case");
+const camelCaseToHumanReadable_1 = require("../utils/camelCaseToHumanReadable");
+const intl_1 = require("../utils/intl");
+const generateGridToolbar = ({ componentName, forwardToolbarAction, hasSearch, hasFilter, excelExport, allowAdding, instanceGqlType, gqlType, newEntryText, fragmentName, }) => {
+    return `${renderToolbarProps(componentName, !!forwardToolbarAction, !!excelExport)}
+    function ${componentName}(${getGridToolbarProps(componentName, !!forwardToolbarAction, !!excelExport)}) {
+        return (
+            <DataGridToolbar>
+                ${hasSearch ? searchItem : ""}
+                ${hasFilter ? filterItem : ""}
+                <FillSpace />
+                ${renderToolbarActions({
+        forwardToolbarAction,
+        addItemText: (0, intl_1.getFormattedMessageNode)(`${instanceGqlType}.${(0, change_case_1.camelCase)(fragmentName)}.newEntry`, newEntryText !== null && newEntryText !== void 0 ? newEntryText : `New ${(0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(gqlType)}`),
+        excelExport,
+        allowAdding,
+    })}
+            </DataGridToolbar>
+        );
+    }`.replace(/^\s+\n/gm, "");
+};
+exports.generateGridToolbar = generateGridToolbar;
+const getGridToolbarProps = (componentName, toolbarAction, exportApi) => {
+    const props = [];
+    if (toolbarAction) {
+        props.push({
+            destructured: "toolbarAction",
+            typeDefinition: "toolbarAction?: ReactNode",
+        });
+    }
+    if (exportApi) {
+        props.push({
+            destructured: "exportApi",
+            typeDefinition: "exportApi: ExportApi",
+        });
+    }
+    if (!props.length) {
+        return "";
+    }
+    return `{
+        ${props.map((prop) => `${prop.destructured}`).join(",")}
+    }: ${componentName}ToolbarProps`;
+};
+const searchItem = `<ToolbarItem>
+    <GridToolbarQuickFilter />
+</ToolbarItem>`;
+const filterItem = `<ToolbarItem>
+    <GridFilterButton />
+</ToolbarItem>`;
+const renderToolbarActions = ({ forwardToolbarAction, addItemText, excelExport, allowAdding }) => {
+    const showMoreActionsMenu = excelExport;
+    if (!showMoreActionsMenu && !allowAdding) {
+        return "";
+    }
+    const moreActionsMenu = `<CrudMoreActionsMenu
+        slotProps={{
+            button: {
+                responsive: true
+            }
+        }}
+        overallActions={[
+            ${excelExport
+        ? `{
+                        label: <FormattedMessage {...messages.downloadAsExcel} />,
+                        icon: exportApi.loading ? <CircularProgress size={20} /> : <Excel />,
+                        onClick: () => exportApi.exportGrid(),
+                        disabled: exportApi.loading,
+                    }`
+        : ""}
+        ]}
+    />`;
+    const defaultAddItemButton = `<Button responsive startIcon={<AddIcon />} component={StackLink} pageName="add" payload="add">
+        ${addItemText}
+    </Button>`;
+    const addAction = forwardToolbarAction ? "{toolbarAction}" : defaultAddItemButton;
+    return `<ToolbarActions>
+        ${showMoreActionsMenu ? moreActionsMenu : ""}
+        ${allowAdding ? addAction : ""}
+    </ToolbarActions>`;
+};
+const renderToolbarProps = (componentName, forwardToolbarAction, exportApi) => {
+    if (forwardToolbarAction || exportApi) {
+        return `interface ${componentName}ToolbarProps extends GridToolbarProps {
+         ${forwardToolbarAction && "toolbarAction: ReactNode;"}
+         ${exportApi ? "exportApi: ExportApi;" : ""}
+}`;
+    }
+    return "";
+};

package/lib/commands/generate/generateGrid/getForwardedGqlArgs.d.ts

@@ -0,0 +1,14 @@
+import { type IntrospectionField } from "graphql";
+import { type Imports } from "../utils/generateImportsCode";
+import { type Prop } from "./generateGrid";
+type GqlArg = {
+    type: string;
+    name: string;
+    queryOrMutationName: string;
+};
+export declare function getForwardedGqlArgs(gqlFields: IntrospectionField[]): {
+    imports: Imports;
+    props: Prop[];
+    gqlArgs: GqlArg[];
+};
+export {};

package/lib/commands/generate/generateGrid/getForwardedGqlArgs.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getForwardedGqlArgs = void 0;
+function getForwardedGqlArgs(gqlFields) {
+    const supportedGqlArgs = ["offset", "limit", "sort", "search", "filter", "scope", "input"]; // this arguments need to be handled differently or are already handled somewhere else
+    const imports = [];
+    const props = [];
+    const gqlArgs = [];
+    getArgs(gqlFields, supportedGqlArgs).forEach((arg) => {
+        if (arg.type === "ID" || arg.type === "String" || arg.type === "DateTime") {
+            props.push({ name: arg.name, optional: false, type: "string" });
+        }
+        else if (arg.type === "Boolean") {
+            props.push({ name: arg.name, optional: false, type: "boolean" });
+        }
+        else if (arg.type === "Int" || arg.type === "Float") {
+            props.push({ name: arg.name, optional: false, type: "number" });
+        }
+        else if (arg.type === "JSONObject") {
+            props.push({ name: arg.name, optional: false, type: "unknown" });
+        }
+        else {
+            props.push({ name: arg.name, optional: false, type: arg.type });
+            imports.push({ name: arg.type, importPath: "@src/graphql.generated" });
+        }
+        gqlArgs.push({ name: arg.name, type: arg.type, queryOrMutationName: arg.gqlField.name });
+    });
+    return {
+        imports,
+        props,
+        gqlArgs,
+    };
+}
+exports.getForwardedGqlArgs = getForwardedGqlArgs;
+function getArgs(gqlFields, skipGqlArgs) {
+    return gqlFields.reduce((acc, gqlField) => {
+        gqlField.args.forEach((gqlArg) => {
+            if (skipGqlArgs.includes(gqlArg.name))
+                return acc;
+            if (gqlArg.type.kind !== "NON_NULL" || gqlArg.defaultValue)
+                return acc;
+            const gqlType = gqlArg.type.ofType;
+            let type = "unknown";
+            if (gqlType.kind === "SCALAR") {
+                const nativeScalars = ["ID", "String", "Boolean", "Int", "Float", "DateTime", "JSONObject"];
+                if (!nativeScalars.includes(gqlType.name)) {
+                    // probably just add to gqlFields-array, but needs to be tested
+                    console.warn(`Currently not supported special SCALAR of type ${gqlType.name} in param ${gqlArg.name} of ${gqlField.name}`);
+                }
+                else {
+                    type = gqlType.name;
+                }
+            }
+            else if (gqlType.kind === "INPUT_OBJECT") {
+                type = gqlType.name;
+            }
+            else {
+                throw new Error(`Not supported kind ${gqlType.kind}, arg: ${gqlArg.name}`);
+            }
+            acc.push({ name: gqlArg.name, type, gqlArg, gqlField });
+        });
+        return acc;
+    }, []);
+}

package/lib/commands/generate/generateGrid/getPropsForFilterProp.d.ts

@@ -0,0 +1,12 @@
+import { type IntrospectionInputObjectType } from "graphql";
+import { type GridConfig } from "../generate-command";
+import { type Imports } from "../utils/generateImportsCode";
+import { type Prop } from "./generateGrid";
+export declare function getPropsForFilterProp({ config, filterType, }: {
+    config: GridConfig<any>;
+    filterType: IntrospectionInputObjectType;
+}): {
+    hasFilterProp: boolean;
+    imports: Imports;
+    props: Prop[];
+};

package/lib/commands/generate/generateGrid/getPropsForFilterProp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropsForFilterProp = void 0;
+function getPropsForFilterProp({ config, filterType, }) {
+    if (!config.filterProp)
+        return { hasFilterProp: false, imports: [], props: [] };
+    const filterTypeName = `GQL${filterType.name}`;
+    return {
+        hasFilterProp: true,
+        imports: [{ name: filterTypeName, importPath: "@src/graphql.generated" }],
+        props: [{ name: "filter", optional: true, type: filterTypeName }],
+    };
+}
+exports.getPropsForFilterProp = getPropsForFilterProp;

package/lib/commands/generate/generateGrid/usableFields.d.ts

@@ -0,0 +1,8 @@
+type GqlLeaves<T> = T extends any ? "__typename" extends keyof T ? {
+    [K in keyof T as K extends "__typename" ? never : K]-?: GqlLeaves<T[K]>;
+} : never : never;
+type FieldNames<T> = {
+    [K in keyof T]: `${Exclude<K, symbol>}${FieldNames<T[K]> extends never ? "" : `.${FieldNames<T[K]>}`}`;
+}[keyof T];
+export type UsableFields<T> = FieldNames<GqlLeaves<T>>;
+export {};

package/lib/commands/generate/generateGrid/usableFields.js

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

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

@@ -0,0 +1 @@
+export declare function camelCaseToHumanReadable(s: string): string;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelCaseToHumanReadable = void 0;
+const change_case_1 = require("change-case");
+function camelCaseToHumanReadable(s) {
+    return (0, change_case_1.capitalCase)(s);
+}
+exports.camelCaseToHumanReadable = camelCaseToHumanReadable;

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

@@ -0,0 +1,6 @@
+import { type Breakpoint } from "@mui/material";
+type BreakpointKey = `'${Breakpoint}'` | number;
+type SingleValueBrakpointTypes = "up" | "down" | "only" | "not";
+type MultiValueBrakpointTypes = "between";
+export type ColumnVisibleOption = `${SingleValueBrakpointTypes}(${BreakpointKey})` | `${MultiValueBrakpointTypes}(${BreakpointKey}, ${BreakpointKey})`;
+export {};

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

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

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

@@ -0,0 +1,3 @@
+import { type IntrospectionQuery } from "graphql";
+export declare function findMutationType(mutationName: string, schema: IntrospectionQuery): import("graphql").IntrospectionField | undefined;
+export declare function findMutationTypeOrThrow(mutationName: string, schema: IntrospectionQuery): import("graphql").IntrospectionField;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMutationTypeOrThrow = exports.findMutationType = void 0;
+function findMutationType(mutationName, schema) {
+    if (!schema.__schema.mutationType)
+        throw new Error("Schema has no Mutation type");
+    const queryType = schema.__schema.types.find((type) => { var _a; return type.name === ((_a = schema.__schema.mutationType) === null || _a === void 0 ? void 0 : _a.name); });
+    if (!queryType)
+        throw new Error("Can't find Mutation type in gql schema");
+    return queryType.fields.find((field) => field.name === mutationName);
+}
+exports.findMutationType = findMutationType;
+function findMutationTypeOrThrow(mutationName, schema) {
+    const ret = findMutationType(mutationName, schema);
+    if (!ret)
+        throw new Error(`Can't find Mutation ${mutationName} in gql schema`);
+    return ret;
+}
+exports.findMutationTypeOrThrow = findMutationTypeOrThrow;

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

@@ -0,0 +1,2 @@
+import { type IntrospectionQuery } from "graphql";
+export declare function findQueryTypeOrThrow(queryName: string, schema: IntrospectionQuery): import("graphql").IntrospectionField;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findQueryTypeOrThrow = void 0;
+function findQueryType(queryName, schema) {
+    const queryType = schema.__schema.types.find((type) => type.name === schema.__schema.queryType.name);
+    if (!queryType)
+        throw new Error("Can't find Query type in gql schema");
+    const ret = queryType.fields.find((field) => field.name === queryName);
+    if (!ret)
+        throw new Error(`Can't find query ${queryName} in gql schema`);
+    return ret;
+}
+function findQueryTypeOrThrow(queryName, schema) {
+    const ret = findQueryType(queryName, schema);
+    if (!ret)
+        throw new Error(`Can't find query ${queryName} in gql schema`);
+    return ret;
+}
+exports.findQueryTypeOrThrow = findQueryTypeOrThrow;

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

@@ -0,0 +1,8 @@
+import { type IntrospectionQuery } from "graphql";
+export declare function findRootBlocks({ gqlType, targetDirectory }: {
+    gqlType: string;
+    targetDirectory: string;
+}, schema: IntrospectionQuery): Record<string, {
+    import: string;
+    name: string;
+}>;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRootBlocks = void 0;
+const fs_1 = require("fs");
+const fallbackLibraryBlocks = {
+    AnchorBlock: "@comet/cms-admin",
+    DamImageBlock: "@comet/cms-admin",
+    DamVideoBlock: "@comet/cms-admin",
+    ExternalLinkBlock: "@comet/cms-admin",
+    InternalLinkBlock: "@comet/cms-admin",
+    PixelImageBlock: "@comet/cms-admin",
+    SpaceBlock: "@comet/cms-admin",
+    SvgImageBlock: "@comet/cms-admin",
+    YouTubeVideoBlock: "@comet/cms-admin",
+};
+function findRootBlocks({ gqlType, targetDirectory }, schema) {
+    const ret = {};
+    const schemaEntity = schema.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+    if (!schemaEntity)
+        throw new Error("didn't find entity in schema types");
+    schemaEntity.fields.forEach((field) => {
+        if (ret[field.name])
+            return; // already defined
+        let type = field.type;
+        if (type.kind == "NON_NULL")
+            type = type.ofType;
+        if (type.kind == "SCALAR" && type.name.endsWith("BlockData")) {
+            let match = false;
+            const blockName = `${type.name.replace(/BlockData$/, "")}Block`;
+            const checkNames = [
+                {
+                    folderName: `${targetDirectory.replace(/\/generated$/, "")}/blocks`,
+                    import: `../blocks/${blockName}`,
+                },
+                {
+                    folderName: `src/common/blocks`,
+                    import: `@src/common/blocks/${blockName}`,
+                },
+            ];
+            for (const checkName of checkNames) {
+                if ((0, fs_1.existsSync)(`${checkName.folderName}/${blockName}.tsx`)) {
+                    match = true;
+                    ret[field.name] = {
+                        import: checkName.import,
+                        name: blockName,
+                    };
+                    break;
+                }
+            }
+            if (!match) {
+                const fallback = fallbackLibraryBlocks[blockName];
+                if (fallback) {
+                    ret[field.name] = {
+                        import: fallback,
+                        name: blockName,
+                    };
+                    match = true;
+                }
+            }
+            if (!match) {
+                throw new Error(`Didn't find admin block for ${blockName} in ${checkNames.map((c) => c.folderName).join(" or ")}`);
+            }
+        }
+    });
+    return ret;
+}
+exports.findRootBlocks = findRootBlocks;

package/lib/commands/generate/utils/generateImportsCode.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/generateImportsCode.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportsCode = void 0;
+// 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 importsString = filteredImports
+        .map((imp) => {
+        return `import { ${imp.name} } from "${imp.importPath}";`;
+    })
+        .join("\n");
+    return importsString;
+}
+exports.generateImportsCode = generateImportsCode;

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

@@ -0,0 +1 @@
+export declare const getFormattedMessageNode: (id: string, defaultMessage?: string, values?: string) => string;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFormattedMessageNode = void 0;
+const getFormattedMessageNode = (id, defaultMessage = "", values) => {
+    return `<FormattedMessage id="${id}" defaultMessage={\`${defaultMessage}\`} ${values ? `values={${values}}` : ""} />`;
+};
+exports.getFormattedMessageNode = getFormattedMessageNode;

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

@@ -0,0 +1,7 @@
+import { type IntrospectionQuery } from "graphql";
+import { type FormFieldConfig } from "../generate-command";
+export declare const isFieldOptional: ({ config, gqlIntrospection, gqlType, }: {
+    config: FormFieldConfig<any>;
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
+}) => boolean;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFieldOptional = void 0;
+const isFieldOptional = ({ config, gqlIntrospection, gqlType, }) => {
+    if (config.required !== undefined) {
+        return !config.required;
+    }
+    if (config.readOnly) {
+        return true;
+    }
+    const schemaEntity = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+    if (!schemaEntity)
+        throw new Error(`didn't find entity ${gqlType} in schema types`);
+    if (schemaEntity.kind !== "OBJECT")
+        throw new Error(`kind of ${gqlType} is not object, but should be.`); // this should not happen
+    const fieldDef = schemaEntity.fields.find((field) => field.name === String(config.name));
+    if (!fieldDef)
+        throw new Error(`didn't find field ${String(config.name)} of ${gqlType} in introspected gql-schema.`);
+    return fieldDef.type.kind !== "NON_NULL";
+};
+exports.isFieldOptional = isFieldOptional;

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

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

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

@@ -0,0 +1,57 @@
+"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.writeGenerated = void 0;
+const eslint_1 = require("eslint");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+function writeGenerated(filePath, contents) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const header = `// This file has been generated by comet admin-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 });
+        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;
+        yield fs_1.promises.writeFile(filePath, output !== null && output !== void 0 ? output : contents);
+        console.log(`generated ${filePath}`);
+    });
+}
+exports.writeGenerated = writeGenerated;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export type { FormConfig, FormFieldConfig, GeneratorConfig, GridColumnConfig, GridConfig } from "./commands/generate/generate-command";

package/lib/index.js

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

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@comet/admin-generator",
+  "version": "8.0.0-beta.0",
+  "repository": {
+    "directory": "packages/admin/admin-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-admin-generator": "bin/admin-generator.js"
+  },
+  "files": [
+    "bin/**/*.js",
+    "lib/*"
+  ],
+  "dependencies": {
+    "@graphql-tools/graphql-file-loader": "^7.5.17",
+    "@graphql-tools/load": "^7.8.14",
+    "change-case": "^4.1.2",
+    "commander": "^9.5.0",
+    "glob": "^10.4.5",
+    "graphql": "^16.10.0",
+    "object-path": "^0.11.8",
+    "pluralize": "^8.0.0",
+    "ts-node": "^10.9.2"
+  },
+  "devDependencies": {
+    "@mui/material": "^6.4.5",
+    "@mui/x-data-grid": "^7.27.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.4",
+    "@types/object-path": "^0.11.4",
+    "@types/pluralize": "^0.0.33",
+    "@types/react": "^18.3.18",
+    "eslint": "^9.20.1",
+    "jest": "^29.7.0",
+    "npm-run-all2": "^5.0.2",
+    "prettier": "^3.5.1",
+    "react": "^18.3.1",
+    "react-intl": "^6.8.9",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.2.5",
+    "typescript": "^4.9.5",
+    "@comet/admin": "8.0.0-beta.0",
+    "@comet/admin-icons": "8.0.0-beta.0",
+    "@comet/cms-admin": "8.0.0-beta.0",
+    "@comet/eslint-config": "8.0.0-beta.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": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
+  }
+}