@gadmin2n/prisma-react-generator 0.0.35

package/dist/generator/helpers.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDocumentation = exports.getModelsEnum = exports.isEnumField = exports.getModelsFieldsTypeMap = exports.globToFieldList = exports.structFilteredByGlob = exports.getPrismaReadStruct = exports.zipImportStatementParams = exports.mergeImportStatements = exports.getRelationScalars = exports.mapDMMFToParsedField = exports.makeImportsFromPrismaClient = exports.flattenObj = exports.isObject = exports.pick = exports.omit = exports.isGameAngle = exports.concatIntoArray = exports.uniq = void 0;
+const template_helpers_1 = require("./template-helpers");
+const notation_1 = require("notation");
+const { readFileSync } = require('fs');
+const uniq = (input) => Array.from(new Set(input));
+exports.uniq = uniq;
+const concatIntoArray = (source, target) => source.forEach((item) => target.push(item));
+exports.concatIntoArray = concatIntoArray;
+function isGameAngle(model) {
+    return (model.fields.find((field) => field.name === 'gameId') &&
+        JSON.parse(readFileSync('./gadmin-cli.json', 'utf8')).template ===
+            'gadmin2-game-angle-demo');
+}
+exports.isGameAngle = isGameAngle;
+function omit(obj, fields) {
+    const shallowCopy = Object.assign({}, obj);
+    for (let i = 0; i < fields.length; i += 1) {
+        const key = fields[i];
+        delete shallowCopy[key];
+    }
+    return shallowCopy;
+}
+exports.omit = omit;
+function pick(obj, fields) {
+    const shallowCopy = {};
+    for (let i = 0; i < fields.length; i += 1) {
+        const key = fields[i];
+        shallowCopy[key] = obj[key];
+    }
+    return shallowCopy;
+}
+exports.pick = pick;
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+exports.isObject = isObject;
+function _flattenObj(obj, target, parent) {
+    Object.entries(obj).forEach(([key, value]) => {
+        let newKey;
+        if (parent === undefined) {
+            newKey = key;
+        }
+        else {
+            newKey = `${parent}.${key}`;
+        }
+        if (isObject(value)) {
+            _flattenObj(value, target, newKey);
+        }
+        else if (Array.isArray(value) && value.length > 0) {
+            if (isObject(value[0])) {
+                Object.getOwnPropertyNames(value[0]).forEach((subKey) => {
+                    target[`${newKey}.${subKey}`] = value
+                        .map((item) => item[subKey])
+                        .join('; ');
+                });
+            }
+        }
+        else {
+            target[newKey] = value;
+        }
+    });
+}
+function flattenObj(obj) {
+    const flattenedObject = {};
+    _flattenObj(obj, flattenedObject);
+    return flattenedObject;
+}
+exports.flattenObj = flattenObj;
+const makeImportsFromPrismaClient = (fields) => {
+    const enumsToImport = (0, exports.uniq)(fields.filter(({ kind }) => kind === 'enum').map(({ type }) => type));
+    const importPrisma = fields
+        .filter(({ kind }) => kind === 'scalar')
+        .some(({ type }) => (0, template_helpers_1.scalarToTS)(type).includes('Prisma'));
+    if (!(enumsToImport.length || importPrisma)) {
+        return null;
+    }
+    return {
+        from: '@prisma/client',
+        destruct: importPrisma ? ['Prisma', ...enumsToImport] : enumsToImport,
+    };
+};
+exports.makeImportsFromPrismaClient = makeImportsFromPrismaClient;
+const mapDMMFToParsedField = (field, overrides = {}) => ({
+    ...field,
+    ...overrides,
+});
+exports.mapDMMFToParsedField = mapDMMFToParsedField;
+const getRelationScalars = (fields) => {
+    const scalars = fields.flatMap(({ relationFromFields = [] }) => relationFromFields);
+    return scalars.reduce((result, scalar) => ({
+        ...result,
+        [scalar]: fields
+            .filter(({ relationFromFields = [] }) => relationFromFields.includes(scalar))
+            .map(({ name }) => name),
+    }), {});
+};
+exports.getRelationScalars = getRelationScalars;
+const mergeImportStatements = (first, second) => {
+    if (first.from !== second.from) {
+        throw new Error(`Can not merge import statements; 'from' parameter is different`);
+    }
+    if (first.default && second.default) {
+        throw new Error(`Can not merge import statements; both statements have set the 'default' preoperty`);
+    }
+    const firstDestruct = first.destruct || [];
+    const secondDestruct = second.destruct || [];
+    const destructStrings = (0, exports.uniq)([...firstDestruct, ...secondDestruct].filter((destructItem) => typeof destructItem === 'string'));
+    const destructObject = [...firstDestruct, ...secondDestruct].reduce((result, destructItem) => {
+        if (typeof destructItem === 'string')
+            return result;
+        return { ...result, ...destructItem };
+    }, {});
+    return {
+        ...first,
+        ...second,
+        destruct: [...destructStrings, destructObject],
+    };
+};
+exports.mergeImportStatements = mergeImportStatements;
+const zipImportStatementParams = (items) => {
+    const itemsByFrom = items.reduce((result, item) => {
+        const { from } = item;
+        const { [from]: existingItem } = result;
+        if (!existingItem) {
+            return { ...result, [from]: item };
+        }
+        return { ...result, [from]: (0, exports.mergeImportStatements)(existingItem, item) };
+    }, {});
+    return Object.values(itemsByFrom);
+};
+exports.zipImportStatementParams = zipImportStatementParams;
+function getPrismaReadStruct(allModels) {
+    const models = {};
+    const relationFromFields = {};
+    for (const model of allModels.values()) {
+        const obj = {};
+        model.fields.forEach((field) => {
+            if (field.kind === 'scalar' || field.kind === 'enum') {
+                obj[field.name] = true;
+            }
+            else if (field.kind === 'object') {
+                obj[field.name] = field.type;
+                if (typeof obj['__DUMMY'] === 'object') {
+                    obj['__DUMMY'][field.name] = true;
+                }
+                else {
+                    obj['__DUMMY'] = { [field.name]: true };
+                }
+                if (field.isList) {
+                    if (typeof obj['_count'] === 'object') {
+                        obj['_count'][field.name] = true;
+                    }
+                    else {
+                        obj['_count'] = { [field.name]: true };
+                    }
+                }
+                else {
+                    relationFromFields[model.name] = [
+                        ...(field.relationFromFields || []),
+                        ...(relationFromFields[model.name] || []),
+                    ];
+                }
+            }
+        });
+        models[model.name] = obj;
+    }
+    for (const [name, model] of Object.entries(models)) {
+        for (const [k, v] of Object.entries(model)) {
+            if ((relationFromFields[name] || []).includes(k)) {
+                delete model[k];
+            }
+            if (k !== '_count' && k !== '__DUMMY' && v !== true) {
+                const obj = {};
+                Object.entries(models[v]).forEach(([key, value]) => {
+                    if (value === true) {
+                        obj[key] = true;
+                    }
+                });
+                model[k] = obj;
+            }
+        }
+    }
+    return models;
+}
+exports.getPrismaReadStruct = getPrismaReadStruct;
+function getObjectKeysOrder(obj) {
+    const res = {};
+    Object.getOwnPropertyNames(obj).forEach((k1, index1) => {
+        res[k1] = index1 * 100000;
+        if (isObject(obj[k1])) {
+            Object.getOwnPropertyNames(obj).forEach((k2, index2) => {
+                res[`${k1}.${k2}`] = res[k1] + index2 + 1;
+            });
+        }
+    });
+    return res;
+}
+function getArrayKeysOrder(arr) {
+    const res = {};
+    arr.forEach((k, index) => {
+        res[k] = index;
+    });
+    return res;
+}
+function structFilteredByGlob(dmmf, modelName, notationGlob, type = 'read') {
+    var _a, _b;
+    let struct = getPrismaReadStruct(dmmf);
+    if (type === 'write') {
+        for (const model of Object.values(struct)) {
+            Object.entries(model).forEach(([k, v]) => {
+                if (k.startsWith('_count')) {
+                    delete model[k];
+                }
+                else if (k.startsWith('__DUMMY')) {
+                    delete model[k];
+                }
+                else if (typeof v === 'object') {
+                    delete model[k];
+                    model[k] = { connect: true };
+                }
+            });
+        }
+    }
+    const filteredGlob = notationGlob
+        .filter((item) => item)
+        .filter((item) => item.trim());
+    const filtered = notation_1.Notation.create(struct[modelName]).filter(filteredGlob).value;
+    if (!((_b = (_a = notationGlob[0]) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, '*'))) {
+        const obj = {};
+        Object.getOwnPropertyNames(struct[modelName]).forEach((k1) => {
+            if (filtered[k1]) {
+                obj[k1] = filtered[k1];
+                if (isObject(filtered[k1])) {
+                    if (isObject(struct[modelName][k1])) {
+                        obj[k1] = {};
+                    }
+                    Object.getOwnPropertyNames(struct[modelName][k1]).forEach((k2) => {
+                        if (filtered[k1][k2]) {
+                            obj[k1][k2] = filtered[k1][k2];
+                        }
+                    });
+                }
+            }
+        });
+        return obj;
+    }
+    return filtered;
+}
+exports.structFilteredByGlob = structFilteredByGlob;
+function globToFieldList(dmmf, modelName, glob = ['*'], type = 'read') {
+    const filteredSelect = structFilteredByGlob(dmmf, modelName, glob, type);
+    return Object.getOwnPropertyNames(flattenObj(filteredSelect || {}));
+}
+exports.globToFieldList = globToFieldList;
+function getModelsFieldsTypeMap(models) {
+    return models.reduce((acc, curModel) => {
+        acc[curModel.name] = curModel.fields.reduce((acc2, curField) => {
+            acc2[curField.name] = curField;
+            return acc2;
+        }, {});
+        return acc;
+    }, {});
+}
+exports.getModelsFieldsTypeMap = getModelsFieldsTypeMap;
+function isEnumField(field) {
+    const { formItem: { type }, } = parseDocumentation(field.documentation || '', field);
+    return (field.kind === 'enum' || ['CheckBox', 'Radio', 'Select'].includes(type));
+}
+exports.isEnumField = isEnumField;
+function getModelsEnum(enumTypesModel) {
+    return enumTypesModel.reduce((acc, cur) => {
+        acc[cur.name] = cur.values.reduce((acc2, value) => {
+            acc2[value] = value;
+            return acc2;
+        }, {});
+        return acc;
+    }, {});
+}
+exports.getModelsEnum = getModelsEnum;
+function parseDocumentation(documentation, field) {
+    var _a;
+    const formFieldRe = /@FormItem\(([^\)]+)\)/gi;
+    const matches = formFieldRe.exec(documentation);
+    let fieldType = 'String';
+    let args = [];
+    if (matches) {
+        [fieldType, ...args] = matches[1].split(',').map((arg) => arg.trim());
+        args = args.map(arg => arg.trim());
+    }
+    else {
+        if ([
+            'String',
+            'Boolean',
+            'Int',
+            'BigInt',
+            'Float',
+            'Decimal',
+            'DateTime',
+        ].includes(field.type)) {
+            fieldType = field.type;
+        }
+        else {
+            fieldType = 'Other';
+        }
+    }
+    if (fieldType === 'File' || fieldType === 'Image') {
+        return {
+            formItem: {
+                type: fieldType,
+                args: {
+                    accept: ((_a = args[0]) === null || _a === void 0 ? void 0 : _a.split('|').map((arg) => arg.trim()).join(', ')) || '*',
+                    maxCount: Number(args[1] || '1'),
+                    sizeLimit: Number(args[2]) || 1024 * 1024 * 10,
+                },
+            },
+        };
+    }
+    else if (fieldType === 'Text') {
+        return {
+            formItem: {
+                type: fieldType,
+                args: { rows: Number(args[0] || '5') },
+            },
+        };
+    }
+    else if (['CheckBox', 'Radio'].includes(fieldType)) {
+        return {
+            formItem: {
+                type: fieldType,
+                args: { options: (args[0] || '').split('|').map((arg) => arg.trim()) },
+            },
+        };
+    }
+    else if (fieldType === 'Select') {
+        return {
+            formItem: {
+                type: fieldType,
+                args: {
+                    options: (args[0] || '').split('|').map((arg) => arg.trim()),
+                    mode: args[1],
+                },
+            },
+        };
+    }
+    else {
+        return {
+            formItem: {
+                type: fieldType,
+                args: {},
+            },
+        };
+    }
+}
+exports.parseDocumentation = parseDocumentation;

package/dist/generator/index.d.ts

@@ -0,0 +1,9 @@
+import type { DMMF } from '@prisma/generator-helper';
+import { NamingStyle, WriteableFileSpecs } from './types';
+interface RunParam {
+    output: string;
+    dmmf: DMMF.Document;
+    fileNamingStyle: NamingStyle;
+}
+export declare const run: ({ output, dmmf, ...options }: RunParam) => WriteableFileSpecs[];
+export {};

package/dist/generator/index.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const case_1 = require("case");
+const sdk_1 = require("@prisma/sdk");
+const template_helpers_1 = require("./template-helpers");
+const field_classifiers_1 = require("./field-classifiers");
+const generate_resources_1 = require("./generate-resources");
+const generate_config_props_1 = require("./generate-config-props");
+const generate_model_props_1 = require("./generate-model-props");
+const generate_create_page_1 = require("./generate-create-page");
+const generate_edit_page_1 = require("./generate-edit-page");
+const generate_index_page_1 = require("./generate-index-page");
+const generate_list_page_1 = require("./generate-list-page");
+const generate_show_page_1 = require("./generate-show-page");
+const generate_ui_config_1 = require("./generate-ui-config");
+const generate_models_index_1 = require("./generate-models-index");
+const IGNORE_REACT_CODE = /@IgnoreReactCode/;
+const run = ({ output, dmmf, ...options }) => {
+    const { fileNamingStyle = 'camel', ...preAndSuffixes } = options;
+    const transformers = {
+        camel: case_1.camel,
+        kebab: case_1.kebab,
+        pascal: case_1.pascal,
+        snake: case_1.snake,
+    };
+    const transformFileNameCase = transformers[fileNamingStyle];
+    const templateHelpers = (0, template_helpers_1.makeHelpers)({
+        ...preAndSuffixes,
+    });
+    const allModels = dmmf.datamodel.models.filter((model) => !(0, field_classifiers_1.isAnnotatedWith)(model, IGNORE_REACT_CODE));
+    const resourcesFile = {
+        fileName: node_path_1.default.join(output, 'resources.tsx'),
+        content: (0, generate_resources_1.generateResources)({
+            models: allModels,
+            templateHelpers,
+        }),
+    };
+    const modelsIndexFile = {
+        fileName: node_path_1.default.join(output, 'models.index.tsx'),
+        content: (0, generate_models_index_1.generateModelsIndex)({
+            models: allModels,
+            enums: dmmf.schema.enumTypes.model || [],
+            templateHelpers,
+        }),
+    };
+    const enums = dmmf.schema.enumTypes.model;
+    const uiConfig = (0, generate_ui_config_1.addNewModelsConfig)(allModels, enums);
+    const modelUIFiles = allModels.map((model) => {
+        sdk_1.logger.info(`Processing Model ${model.name}`);
+        const configFile = {
+            fileName: node_path_1.default.join(output, 'props', transformFileNameCase(model.name), `config.ts`),
+            content: (0, generate_config_props_1.generateConfigProps)({
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        const modelFile = {
+            fileName: node_path_1.default.join(output, 'props', transformFileNameCase(model.name), `model.ts`),
+            content: (0, generate_model_props_1.generateModelProps)({
+                dmmf,
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        const createPageFile = {
+            fileName: node_path_1.default.join(output, 'pages', transformFileNameCase(model.name), `create.tsx`),
+            content: (0, generate_create_page_1.generateCreatePage)({
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        const editPageFile = {
+            fileName: node_path_1.default.join(output, 'pages', transformFileNameCase(model.name), `edit.tsx`),
+            content: (0, generate_edit_page_1.generateEditPage)({
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        const indexPageFile = {
+            fileName: node_path_1.default.join(output, 'pages', transformFileNameCase(model.name), `index.tsx`),
+            content: (0, generate_index_page_1.generateIndexPage)({
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        const listPageFile = {
+            fileName: node_path_1.default.join(output, 'pages', transformFileNameCase(model.name), `list.tsx`),
+            content: (0, generate_list_page_1.generateListPage)({
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        const showPageFile = {
+            fileName: node_path_1.default.join(output, 'pages', transformFileNameCase(model.name), `show.tsx`),
+            content: (0, generate_show_page_1.generatePageShow)({
+                model,
+                templateHelpers,
+                uiConfig,
+                allModels,
+            }),
+        };
+        return [
+            configFile,
+            modelFile,
+            createPageFile,
+            editPageFile,
+            indexPageFile,
+            listPageFile,
+            showPageFile,
+        ];
+    });
+    return [[resourcesFile, modelsIndexFile], ...modelUIFiles].flat();
+};
+exports.run = run;

package/dist/generator/template-helpers.d.ts

@@ -0,0 +1,27 @@
+import { ImportStatementParams } from './types';
+export declare const scalarToTS: (scalar: string, useInputTypes?: boolean) => string;
+export declare const echo: (input: string) => string;
+export declare const when: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+export declare const unless: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+export declare const each: <T = any>(arr: T[], fn: (item: T) => string, joinWith?: string) => string;
+export declare const importStatement: (input: ImportStatementParams) => string;
+export declare const importStatements: (items: ImportStatementParams[]) => string;
+interface MakeHelpersParam {
+    transformClassNameCase?: (item: string) => string;
+    transformFileNameCase?: (item: string) => string;
+}
+export declare const makeHelpers: ({ transformClassNameCase, transformFileNameCase, }: MakeHelpersParam) => {
+    config: {};
+    each: <T = any>(arr: T[], fn: (item: T) => string, joinWith?: string) => string;
+    echo: (input: string) => string;
+    for: <T = any>(arr: T[], fn: (item: T) => string, joinWith?: string) => string;
+    if: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+    importStatement: (input: ImportStatementParams) => string;
+    importStatements: (items: ImportStatementParams[]) => string;
+    transformClassNameCase: (item: string) => string;
+    transformFileNameCase: (item: string) => string;
+    unless: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+    when: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+};
+export declare type TemplateHelpers = ReturnType<typeof makeHelpers>;
+export {};

package/dist/generator/template-helpers.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHelpers = exports.importStatements = exports.importStatement = exports.each = exports.unless = exports.when = exports.echo = exports.scalarToTS = void 0;
+const PrismaScalarToTypeScript = {
+    String: 'string',
+    Boolean: 'boolean',
+    Int: 'number',
+    BigInt: 'number',
+    Float: 'number',
+    Decimal: 'number',
+    DateTime: 'Date',
+    Json: 'Prisma.JsonValue',
+    Bytes: 'Buffer',
+};
+const knownPrismaScalarTypes = Object.keys(PrismaScalarToTypeScript);
+const scalarToTS = (scalar, useInputTypes = false) => {
+    if (!knownPrismaScalarTypes.includes(scalar)) {
+        return 'string';
+    }
+    if (useInputTypes && scalar === 'Json') {
+        return 'Prisma.InputJsonValue';
+    }
+    return PrismaScalarToTypeScript[scalar];
+};
+exports.scalarToTS = scalarToTS;
+const echo = (input) => input;
+exports.echo = echo;
+const when = (condition, thenTemplate, elseTemplate = '') => condition ? thenTemplate : elseTemplate;
+exports.when = when;
+const unless = (condition, thenTemplate, elseTemplate = '') => (!condition ? thenTemplate : elseTemplate);
+exports.unless = unless;
+const each = (arr, fn, joinWith = '') => arr.map(fn).join(joinWith);
+exports.each = each;
+const importStatement = (input) => {
+    const { from, destruct = [], default: defaultExport } = input;
+    const fragments = ['import'];
+    if (defaultExport) {
+        if (typeof defaultExport === 'string') {
+            fragments.push(defaultExport);
+        }
+        else {
+            fragments.push(`* as ${defaultExport['*']}`);
+        }
+    }
+    if (destruct.length) {
+        if (defaultExport) {
+            fragments.push(',');
+        }
+        fragments.push(`{${destruct.flatMap((item) => {
+            if (typeof item === 'string')
+                return item;
+            return Object.entries(item).map(([key, value]) => `${key} as ${value}`);
+        })}}`);
+    }
+    fragments.push(`from '${from}'`);
+    return fragments.join(' ');
+};
+exports.importStatement = importStatement;
+const importStatements = (items) => `${(0, exports.each)(items, exports.importStatement, '\n')}`;
+exports.importStatements = importStatements;
+const makeHelpers = ({ transformClassNameCase = exports.echo, transformFileNameCase = exports.echo, }) => {
+    const className = (name, prefix = '', suffix = '') => `${prefix}${transformClassNameCase(name)}${suffix}`;
+    const fileName = (name, prefix = '', suffix = '', withExtension = false) => `${prefix}${transformFileNameCase(name)}${suffix}${(0, exports.when)(withExtension, '.ts')}`;
+    return {
+        config: {},
+        each: exports.each,
+        echo: exports.echo,
+        for: exports.each,
+        if: exports.when,
+        importStatement: exports.importStatement,
+        importStatements: exports.importStatements,
+        transformClassNameCase,
+        transformFileNameCase,
+        unless: exports.unless,
+        when: exports.when,
+    };
+};
+exports.makeHelpers = makeHelpers;

package/dist/generator/types.d.ts

@@ -0,0 +1,27 @@
+import { DMMF } from '@prisma/generator-helper';
+export interface ParsedField {
+    kind: DMMF.FieldKind | 'relation-input';
+    name: string;
+    type: string;
+    documentation?: string;
+    isRequired: boolean;
+    isList: boolean;
+    isNullable?: boolean;
+}
+export interface ExtraModel {
+    originalName: string;
+    preAndPostfixedName: string;
+    isLocal?: boolean;
+}
+export interface ImportStatementParams {
+    from: string;
+    default?: string | {
+        '*': string;
+    };
+    destruct?: (string | Record<string, string>)[];
+}
+export declare type WriteableFileSpecs = {
+    fileName: string;
+    content: string;
+};
+export declare type NamingStyle = 'snake' | 'camel' | 'pascal' | 'kebab';

package/dist/generator/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorOptions } from '@prisma/generator-helper';
+export declare const stringToBoolean: (input: string, defaultValue?: boolean) => boolean;
+export declare const generate: (options: GeneratorOptions) => Promise<void[]>;