@gadmin2n/prisma-react-generator 0.0.35

package/dist/generator/generate-show-page.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePageShow = void 0;
+const case_1 = require("case");
+const fs = require("fs");
+const generatePageShow = ({ model, templateHelpers: t, uiConfig, allModels, }) => {
+    const instanceName = (0, case_1.camel)(model.name);
+    return `
+import { ModelType, getColumns, produceModel } from "@gadmin2/react-common";
+import { CloneButton, DeleteButton, EditButton, ListButton, RefreshButton, Show } from "@refinedev/antd";
+import { IResourceComponentsProps, useShow, useTranslate } from "@refinedev/core";
+import React, { useState } from "react";
+import { getShowField } from "../../helpers";
+import type { ${model.name} } from "../../generated/types/prisma.types"; //'.prisma/client/index';
+import {
+  ${instanceName}ShowConfig as showConfig,
+  ${instanceName}ShowPrismaSelect as showPrismaSelect,
+} from "../../generated/props/${instanceName}/config";
+import { ${instanceName}Model } from "../../generated/props/${instanceName}/model";
+import { modelsMap } from "generated/models.index";
+
+export const ${model.name}Show: React.FC<IResourceComponentsProps> = () => {
+  const resourceName = "${instanceName}";
+  const t = useTranslate();
+  
+  const { queryResult } = useShow<${model.name}>({
+    meta: { select: showPrismaSelect},
+  });
+  const { data, isLoading } = queryResult;
+  const record = data?.data;
+
+  const [[fields, model]] = useState(() => {
+    const model: ModelType = produceModel(${instanceName}Model, {
+      // status: { render: xxxxx }
+    });
+
+    // getColumns is a function that returns an array of fields
+    const fields = getColumns("${model.name}", showConfig.fields, {
+      ...modelsMap,
+      ${model.name}: { model, meta: modelsMap["${model.name}"].meta },
+    });
+
+    return [fields, model] as const;
+  });
+
+  return (
+    <Show
+      isLoading={isLoading}
+      headerButtons={
+        <>
+          <ListButton/>
+          <EditButton recordItemId={record?.id} />
+          <CloneButton recordItemId={record?.id} />
+          <DeleteButton recordItemId={record?.id} />
+          <RefreshButton
+            recordItemId={record?.id}
+            meta={{ select: showPrismaSelect}}
+          />
+        </>
+      }
+    >
+      {fields.map((field: any) => {
+        return getShowField(field, resourceName, record, t, model, modelsMap);
+      })}
+    </Show>
+  );
+};
+
+`;
+};
+exports.generatePageShow = generatePageShow;

package/dist/generator/generate-ui-config.d.ts

@@ -0,0 +1,2 @@
+import { DMMF } from '@prisma/generator-helper';
+export declare function addNewModelsConfig(allModels: DMMF.Model[], enums?: DMMF.SchemaEnum[]): any;

package/dist/generator/generate-ui-config.js

@@ -0,0 +1,354 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNewModelsConfig = void 0;
+const ts = __importStar(require("ts-morph"));
+const shell = __importStar(require("shelljs"));
+const case_1 = require("case");
+const helpers_1 = require("./helpers");
+const path = __importStar(require("path"));
+const fs = require('fs');
+function detectConfigMode() {
+    const hasConfigFile = fs.existsSync('../config/ui.config.ts');
+    const hasConfigDir = fs.existsSync('../config/ui') && fs.statSync('../config/ui').isDirectory();
+    if (hasConfigDir) {
+        return 'directory';
+    }
+    if (hasConfigFile) {
+        return 'file';
+    }
+    return 'none';
+}
+function loadConfigFromDirectory(allModels, enums = []) {
+    console.log('Loading UI config from directory mode (config/ui/) ...');
+    const configDir = '../config/ui';
+    const configDirAbs = path.resolve(configDir);
+    const configFiles = fs.readdirSync(configDir)
+        .filter((file) => file.endsWith('.ts') && !file.endsWith('.d.ts'));
+    if (configFiles.length === 0) {
+        throw new Error('No .ts config files found in config/ui/ directory');
+    }
+    const existingModelNames = new Set();
+    const tsProject = new ts.Project({
+        manipulationSettings: {
+            indentationText: ts.IndentationText.TwoSpaces,
+        },
+    });
+    configFiles.forEach((file) => {
+        const filePath = path.join(configDir, file);
+        try {
+            const sourceFile = tsProject.addSourceFileAtPath(filePath);
+            sourceFile.getVariableDeclarations().forEach((varDecl) => {
+                if (varDecl.isExported()) {
+                    const name = varDecl.getName();
+                    if (!['pageActions', 'PAGE_SIZE', 'modelsConfig'].includes(name)) {
+                        existingModelNames.add(name);
+                    }
+                }
+            });
+        }
+        catch (e) {
+            console.log(`Warning: Failed to parse ${file}: ${e.message}`);
+        }
+    });
+    const newModels = allModels.filter((model) => !existingModelNames.has(model.name));
+    newModels.forEach((model) => {
+        const configContent = generateModelConfigFile(model, enums);
+        const filePath = path.join(configDir, `${model.name}.ts`);
+        fs.writeFileSync(filePath, configContent);
+        console.log(`Created new config file: config/ui/${model.name}.ts`);
+    });
+    console.log('Compile UI config files ...');
+    const { code } = shell.cd(configDirAbs).exec('tsc *.ts --moduleResolution node --esModuleInterop');
+    if (code !== 0) {
+        shell.cd('../../server');
+        process.exit(code);
+    }
+    const modelsConfig = {};
+    let pageActions = null;
+    let PAGE_SIZE = 10;
+    const jsFiles = fs.readdirSync('.')
+        .filter((file) => file.endsWith('.js') && !file.startsWith('_'));
+    const commonJsPath = path.join(configDirAbs, '_common.js');
+    if (fs.existsSync(commonJsPath)) {
+        delete require.cache[require.resolve(commonJsPath)];
+        const commonModule = require(commonJsPath);
+        if (commonModule.pageActions) {
+            pageActions = commonModule.pageActions;
+        }
+        if (commonModule.PAGE_SIZE) {
+            PAGE_SIZE = commonModule.PAGE_SIZE;
+        }
+    }
+    jsFiles.forEach((file) => {
+        const jsFilePath = path.join(configDirAbs, file);
+        delete require.cache[require.resolve(jsFilePath)];
+        const moduleExports = require(jsFilePath);
+        Object.keys(moduleExports).forEach((key) => {
+            if (key === 'pageActions') {
+                pageActions = moduleExports[key];
+            }
+            else if (key === 'PAGE_SIZE') {
+                PAGE_SIZE = moduleExports[key];
+            }
+            else if (key !== 'modelsConfig' && key !== 'default') {
+                modelsConfig[key] = moduleExports[key];
+            }
+        });
+    });
+    shell.rm('-rf', '*.js');
+    shell.cd('../../server');
+    if (!pageActions) {
+        pageActions = {
+            hasDetailPage: true,
+            editOnNewPage: true,
+            detailOnNewPage: true,
+            createOnNewPage: true,
+        };
+    }
+    return {
+        modelsConfig,
+        pageActions,
+        PAGE_SIZE,
+    };
+}
+function loadConfigFromFile(allModels, enums = []) {
+    console.log('Loading UI config from file mode (config/ui.config.ts) ...');
+    const tsProject = new ts.Project({
+        manipulationSettings: {
+            indentationText: ts.IndentationText.TwoSpaces,
+        },
+    });
+    const tsFile = tsProject.addSourceFileAtPath('../config/ui.config.ts');
+    try {
+        const modelsConfig = tsFile
+            .getVariableDeclarationOrThrow('modelsConfig')
+            .getInitializerIfKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression);
+        const tableNames = modelsConfig
+            .getProperties()
+            .map((p) => p.asKindOrThrow(ts.SyntaxKind.PropertyAssignment).getName());
+        allModels
+            .filter((model) => !tableNames.includes(model.name))
+            .forEach((model) => {
+            modelsConfig.addPropertyAssignment({
+                name: model.name,
+                initializer: getModelConfigStruct(model, enums),
+            });
+        });
+        tsFile.saveSync();
+    }
+    catch (e) {
+        console.log('Add new models config to ui.config.ts error:', e.message);
+    }
+    const uiConfig = (function (exports = {}) {
+        console.log('Compile ui.config.ts ...');
+        const { code } = shell.cd('../config/').exec('tsc ui.config.ts');
+        if (code !== 0) {
+            process.exit(code);
+        }
+        const data = fs.readFileSync('ui.config.js');
+        eval(data.toString());
+        shell.rm('-rf', 'ui.config.js');
+        shell.cd('../server');
+        return exports;
+    })();
+    return uiConfig;
+}
+function generateModelConfigFile(model, enums = []) {
+    return `import { ModelConfig } from "../.types";
+import { pageActions, PAGE_SIZE } from "./_common";
+
+export const ${model.name}: ModelConfig = ${getModelConfigStruct(model, enums)};
+`;
+}
+function initializeConfigDirectory(allModels, enums = []) {
+    console.log('No UI config found. Creating config/ui/ directory with default configs ...');
+    const configDir = '../config/ui';
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    const commonConfigContent = `import { PageActions } from "../.types";
+
+/**
+ * 默认分页大小
+ */
+export const PAGE_SIZE = 10;
+
+/**
+ * 全局页面行为配置
+ */
+export const pageActions: PageActions = {
+  hasDetailPage: true,
+  editOnNewPage: true,
+  detailOnNewPage: true,
+  createOnNewPage: true,
+};
+`;
+    fs.writeFileSync(path.join(configDir, '_common.ts'), commonConfigContent);
+    console.log('Created: config/ui/_common.ts');
+    allModels.forEach((model) => {
+        const configContent = generateModelConfigFile(model, enums);
+        const filePath = path.join(configDir, `${model.name}.ts`);
+        fs.writeFileSync(filePath, configContent);
+        console.log(`Created: config/ui/${model.name}.ts`);
+    });
+    return loadConfigFromDirectory(allModels, enums);
+}
+function addNewModelsConfig(allModels, enums = []) {
+    const configMode = detectConfigMode();
+    if (configMode === 'none') {
+        return initializeConfigDirectory(allModels, enums);
+    }
+    else if (configMode === 'directory') {
+        return loadConfigFromDirectory(allModels, enums);
+    }
+    else {
+        return loadConfigFromFile(allModels, enums);
+    }
+}
+exports.addNewModelsConfig = addNewModelsConfig;
+function getModelConfigStruct(model, enums = []) {
+    const relationFields = model.fields
+        .filter((field) => field.kind === 'object' && !field.isList)
+        .map((field) => field.name);
+    const relationsFields = model.fields
+        .filter((field) => field.kind === 'object' && field.isList)
+        .map((field) => field.name);
+    const enumFields = model.fields
+        .filter((field) => (0, helpers_1.isEnumField)(field))
+        .map((field) => field.name);
+    const searchFields = model.fields
+        .filter((field) => ['id', 'title', 'name'].includes(field.name) &&
+        !relationFields.includes(field.name) &&
+        !relationsFields.includes(field.name) &&
+        !enumFields.includes(field.name))
+        .map((field) => field.name);
+    const editableFields = [...relationFields, ...relationsFields].reduce((acc, cur) => {
+        acc.push(`!${cur}.*`);
+        return acc;
+    }, ['*', '!creator', '!createdAt', '!updatedAt']);
+    const textFieldsExclude = model.fields
+        .filter((field) => {
+        const { formItem: { type }, } = (0, helpers_1.parseDocumentation)(field.documentation || '', field);
+        return ['Text', 'Html', 'File', 'Markdown'].includes(type);
+    })
+        .map((field) => `!${field.name}`);
+    const tableFileds = relationsFields
+        .reduce((acc, cur) => {
+        acc.push(`!${cur}.*`);
+        acc.push(`_count.${cur}`);
+        return acc;
+    }, ['*', '!createdAt', ...textFieldsExclude])
+        .concat(relationFields.reduce((acc, cur) => {
+        acc.push(`!${cur}.*`);
+        acc.push(`${cur}`);
+        return acc;
+    }, []));
+    const showFields = tableFileds.filter((fieldName) => !textFieldsExclude.includes(fieldName));
+    function getFirstEnumChangeStatusStr() {
+        const enumField = model.fields.find((field) => field.kind === 'enum');
+        if (enumField) {
+            const enumInfo = enums.find((item) => item.name === enumField.type);
+            if (enumInfo) {
+                return `{
+            action: "CHANGE_STATUS",
+            desc: "${(0, case_1.title)(enumInfo.values[0])}",
+            values: {"${enumField.name}": "${enumInfo.values[0]}"},
+          },`;
+            }
+        }
+        return '';
+    }
+    return `
+{ 
+  metadata: {
+    nameKeys: ["${searchFields.find((name) => ['name', 'title'].includes(name)) || 'id'}"],
+    pageActions,
+  },
+  table: {
+    toolbar: {
+      searchBar: {
+        fields: ${JSON.stringify(searchFields)},
+        containsFields: ${JSON.stringify(searchFields.filter((field) => field !== 'id'))},
+        placeholder: ${JSON.stringify(searchFields.join(','))},
+      },
+      actions: [
+        {action: 'REFRESH', desc: 'Refresh'},
+        {action: 'SETTING', desc: 'Setting'},
+        {
+          action: "EXPORT",
+          desc: 'export',
+          fields: ${JSON.stringify(tableFileds)}
+        },
+      ],
+    },
+    header: {
+      filter: ${JSON.stringify(model.fields
+        .filter((field) => enumFields.includes(field.name) ||
+        (field.kind === 'object' && !field.isList))
+        .map((field) => field.name))},
+      sorter: ${JSON.stringify(['id'].concat(enumFields))},
+    },
+    fields: ${JSON.stringify(tableFileds)},
+    rowSelection: {
+      actions: [
+        {action: 'INSERT', desc: 'Insert'},
+        ${getFirstEnumChangeStatusStr()}
+        {action: 'DELETE', desc: 'Delete'},
+        {action: 'EXPORT', desc: 'Export'},
+      ],
+    },
+    rowActions: {
+      visibleNum: 2,
+      actions: [
+        {
+          action: "EDIT",
+          desc: "Edit",
+        },
+        ${getFirstEnumChangeStatusStr()}
+        {action: "DELETE", desc: 'Delete'}
+      ],
+    },
+    params: {
+      pageSize: PAGE_SIZE,
+    },
+  },
+  form: {
+    fields: ${JSON.stringify(editableFields)},
+    reaction: {
+      id: {
+        toggle: [],
+        defaultProps: {
+          hidden: true,
+        },
+      },
+    },
+  },
+  show: {
+    fields: ${JSON.stringify(showFields)},
+  },
+}
+`;
+}

package/dist/generator/helpers.d.ts

@@ -0,0 +1,55 @@
+import type { DMMF } from '@prisma/generator-helper';
+import type { ImportStatementParams, ParsedField } from './types';
+export declare type GlobType = 'read' | 'write';
+export declare const uniq: <T = any>(input: T[]) => T[];
+export declare const concatIntoArray: <T = any>(source: T[], target: T[]) => void;
+export declare function isGameAngle(model: DMMF.Model): boolean | undefined;
+export declare function omit(obj: Record<string, any>, fields: string[]): Record<string, any>;
+export declare function pick(obj: Record<string, any>, fields: string[]): Record<string, any>;
+export declare function isObject(item: any): any;
+export declare function flattenObj(obj: Record<string, any>): {};
+export declare const makeImportsFromPrismaClient: (fields: ParsedField[]) => ImportStatementParams | null;
+export declare const mapDMMFToParsedField: (field: DMMF.Field, overrides?: Partial<DMMF.Field>) => ParsedField;
+export declare const getRelationScalars: (fields: DMMF.Field[]) => Record<string, string[]>;
+export declare const mergeImportStatements: (first: ImportStatementParams, second: ImportStatementParams) => ImportStatementParams;
+export declare const zipImportStatementParams: (items: ImportStatementParams[]) => ImportStatementParams[];
+export interface IModelSelect {
+    [key: string]: IModelSelect | true | string;
+}
+export declare function getPrismaReadStruct(allModels: DMMF.Model[]): IModelSelect;
+export declare function structFilteredByGlob(dmmf: DMMF.Model[], modelName: string, notationGlob: string[], type?: GlobType): IModelSelect | undefined;
+export declare function globToFieldList(dmmf: DMMF.Model[], modelName: string, glob?: string[], type?: GlobType): string[];
+export declare function getModelsFieldsTypeMap(models: DMMF.Model[]): Record<string, Record<string, DMMF.Field>>;
+export declare function isEnumField(field: DMMF.Field): boolean;
+export declare function getModelsEnum(enumTypesModel: DMMF.SchemaEnum[]): Record<string, Record<string, string>>;
+declare type UiType = {
+    formItem: {
+        type: 'File' | 'Image';
+        args: {
+            maxCount: number;
+            accept: string;
+            sizeLimit: number;
+        };
+    } | {
+        type: 'Text';
+        args: {
+            rows: number;
+        };
+    } | {
+        type: 'CheckBox' | 'Radio';
+        args: {
+            options: string[];
+        };
+    } | {
+        type: 'Select';
+        args: {
+            options: string[];
+            mode?: 'multiple' | undefined;
+        };
+    } | {
+        type: 'String' | 'Boolean' | 'Int' | 'BigInt' | 'Float' | 'Decimal' | 'DateTime' | 'Markdown' | 'Html' | 'Url' | 'Email' | 'Other';
+        args: {};
+    };
+};
+export declare function parseDocumentation(documentation: string, field: DMMF.Field): UiType;
+export {};