@shys/crud 1.0.1-beta.0

package/dist/generator.js

@@ -0,0 +1,322 @@
+import { resolve } from 'node:path';
+import { toCamelCase, toPascalCase, toPluralKebab } from './utils.js';
+import { createRenderer } from './renderer.js';
+const BASE_FIELD_NAMES = ['createTime', 'updateTime', 'deleteTime'];
+const JSTypeMap = {
+    int: 'number', integer: 'number', bigint: 'number', smallint: 'number', tinyint: 'number', mediumint: 'number',
+    decimal: 'number', numeric: 'number', float: 'number', double: 'number', real: 'number',
+    char: 'string', varchar: 'string', text: 'string', tinytext: 'string', mediumtext: 'string', longtext: 'string',
+    enum: 'string', set: 'string', json: 'any',
+    date: 'Date', datetime: 'Date', timestamp: 'Date', time: 'Date', year: 'number',
+    binary: 'Buffer', varbinary: 'Buffer', blob: 'Buffer',
+    bool: 'boolean', boolean: 'boolean', bit: 'boolean',
+};
+const NO_LENGTH_ORM_TYPES = /^(text|tinytext|mediumtext|longtext|blob|tinyblob|mediumblob|longblob|json)$/i;
+function normalizeOrmType(type) {
+    return String(type).toLowerCase().replace(/\(\d+.*?\)/, '').trim() || 'varchar';
+}
+function fieldSupportsLength(f) {
+    return !NO_LENGTH_ORM_TYPES.test(normalizeOrmType(f.type));
+}
+function jsTypeOf(field) {
+    const base = JSTypeMap[field.type] || 'string';
+    if (field.nullable)
+        return `${base} | null`;
+    return base;
+}
+function createDtoTypeOf(field) {
+    const base = JSTypeMap[field.type] || 'string';
+    return `${base}${field.nullable ? ' | null' : ''}`;
+}
+function joiSwagType(f) {
+    const t = f.type;
+    if (t === 'int' || t === 'bigint' || t === 'smallint' || t === 'tinyint' || t === 'mediumint' || t === 'integer')
+        return `'integer'`;
+    if (t === 'decimal' || t === 'numeric' || t === 'float' || t === 'double' || t === 'real' || t === 'number')
+        return `'number'`;
+    if (t === 'datetime' || t === 'timestamp' || t === 'date')
+        return `'string'`;
+    if (t === 'bool' || t === 'boolean')
+        return `'boolean'`;
+    return `'string'`;
+}
+function joiRuleOf(field, opts = {}) {
+    const { required = false, allowNull = false } = opts;
+    const t = field.type;
+    let j;
+    switch (t) {
+        case 'int':
+        case 'integer':
+        case 'bigint':
+        case 'smallint':
+        case 'tinyint':
+        case 'mediumint':
+            j = 'Joi.number().integer()';
+            break;
+        case 'decimal':
+        case 'numeric':
+        case 'float':
+        case 'double':
+        case 'real':
+            j = 'Joi.number()';
+            break;
+        case 'date':
+        case 'datetime':
+        case 'timestamp':
+            j = 'Joi.date()';
+            break;
+        case 'bool':
+        case 'boolean':
+            j = 'Joi.boolean()';
+            break;
+        default:
+            j = 'Joi.string()' + (field.len ? `.max(${field.len})` : '');
+    }
+    if (allowNull)
+        j += '.allow(null)';
+    if (required)
+        j += '.required()';
+    return j;
+}
+function zodRuleOf(field) {
+    const t = field.type;
+    let zodBase;
+    if (/int|bigint|smallint|tinyint|mediumint|integer/.test(t)) {
+        zodBase = 'z.number().int()';
+    }
+    else if (/decimal|numeric|float|double|real/.test(t)) {
+        zodBase = 'z.number()';
+    }
+    else if (/date|datetime|timestamp/.test(t)) {
+        zodBase = 'z.date()';
+    }
+    else if (/bool|boolean/.test(t)) {
+        zodBase = 'z.boolean()';
+    }
+    else {
+        zodBase = `z.string()${field.len ? `.max(${field.len})` : ''}`;
+    }
+    return `${zodBase}.describe(${JSON.stringify(field.comment || field.camel)})`;
+}
+function enhanceField(f, extra = {}) {
+    return {
+        ...f,
+        swagType: joiSwagType(f),
+        jsType: jsTypeOf(f),
+        createDtoType: createDtoTypeOf(f),
+        joiRule: joiRuleOf(f, { required: false, allowNull: f.nullable }),
+        joiRuleRequired: joiRuleOf(f, { required: true, allowNull: f.nullable }),
+        zodRule: zodRuleOf(f),
+        ormType: normalizeOrmType(f.type),
+        supportsLength: fieldSupportsLength(f),
+        isDate: /datetime|date|timestamp/i.test(f.type),
+        isSensitive: /password|passwd|salt|token|secret|private_key/i.test(f.name + f.camel),
+        voType: /datetime|date|timestamp/i.test(f.type) ? 'string' : (JSTypeMap[f.type] || 'string'),
+        idx: !!extra.idx,
+    };
+}
+export function buildFiles(params) {
+    const { moduleName, tableName, baseSrcPath, ormInfo, fields, outputPath, templatesPath, renderer: customRenderer, onlyEntity } = params;
+    const renderer = customRenderer || createRenderer({ customTemplatesPath: templatesPath });
+    const Camel = toCamelCase(tableName);
+    const Pascal = toPascalCase(tableName);
+    const CreateName = `Create${Pascal}Dto`;
+    const UpdateName = `Update${Pascal}Dto`;
+    const ReplaceName = `Replace${Pascal}Dto`;
+    const QueryName = `Query${Pascal}Dto`;
+    const VOName = `${Pascal}VO`;
+    const ListVOName = `${Pascal}ListVO`;
+    const ServiceName = `${Pascal}Service`;
+    const CtrlName = `${Pascal}Controller`;
+    const pluralKebab = toPluralKebab(tableName);
+    const tagName = `${Pascal}管理`;
+    const desc = `${tableName} 表增删改查接口`;
+    const modRoot = resolve(outputPath || baseSrcPath, 'modules', moduleName);
+    const resultFiles = [];
+    const originalPkInfo = fields.find((f) => f.pk);
+    const hasPk = !!originalPkInfo;
+    const entityFields = fields.filter((f) => {
+        if (BASE_FIELD_NAMES.includes(f.camel))
+            return false;
+        if (f.pk)
+            return false;
+        return true;
+    });
+    const idxFields = entityFields.filter((f) => !f.pk && (String(f.name).toUpperCase() === 'COUNTRYCODE' || /_id$/.test(f.name)));
+    const hasDateField = entityFields.some((f) => /datetime|date|timestamp/i.test(f.type));
+    const enhancedEntityFields = entityFields.map((f) => enhanceField(f, { idx: idxFields.some((i) => i.name === f.name) }));
+    const enhancedPkInfo = originalPkInfo ? enhanceField(originalPkInfo) : null;
+    // Entity
+    resultFiles.push({
+        path: resolve(modRoot, `entity/${Camel}.entity.ts`),
+        content: renderer.render('entity', {
+            orm: ormInfo.orm,
+            ormSuffix: ormInfo.ormSuffix,
+            fields: enhancedEntityFields,
+            tableName,
+            Pascal,
+            Camel,
+            pkInfo: enhancedPkInfo,
+            hasPk,
+            hasDateField,
+            idxCount: idxFields.length,
+        }),
+    });
+    if (onlyEntity) {
+        return {
+            files: resultFiles,
+            Pascal,
+            pluralKebab,
+            Camel,
+            sortable: [],
+            filterable: [],
+            searchable: [],
+        };
+    }
+    const createFields = entityFields.filter((f) => !(f.pk && f.auto));
+    const writable = createFields.filter((f) => !/ctime|mtime|created_at|updated_at|create_time|update_time/i.test(f.name));
+    const isSensitive = (f) => /password|passwd|salt|token|secret|private_key/i.test(f.name + f.camel);
+    const pkCamel = originalPkInfo?.camel || '';
+    const sortableBase = entityFields.filter((f) => !isSensitive(f)).map((f) => f.camel);
+    const sortable = pkCamel && !sortableBase.includes(pkCamel)
+        ? [pkCamel, ...sortableBase]
+        : sortableBase;
+    const filterableBase = entityFields.filter((f) => !isSensitive(f));
+    const filterableArr = pkCamel && !filterableBase.some((f) => f.camel === pkCamel)
+        ? [originalPkInfo, ...filterableBase]
+        : filterableBase;
+    const filterable = filterableArr.map((f) => f.camel);
+    const searchable = filterableArr
+        .filter((f) => /char|varchar|text/i.test(f.type))
+        .map((f) => f.camel);
+    const enhancedCreateFields = createFields.map((f) => enhanceField(f));
+    const enhancedWritable = writable.map((f) => enhanceField(f));
+    const enhancedFilterable = filterableArr.map((f) => enhanceField(f));
+    // Create DTO
+    resultFiles.push({
+        path: resolve(modRoot, `dto/${Camel}/create.dto.ts`),
+        content: renderer.render('dto-create', {
+            CreateName,
+            Pascal,
+            createFields: enhancedCreateFields,
+        }),
+    });
+    // Update DTO
+    const updatePicks = enhancedWritable.map((f) => JSON.stringify(f.camel)).join(',\n  ');
+    const updateTypeArgs = enhancedWritable.map((f) => `'${f.camel}'`).join(' | ');
+    resultFiles.push({
+        path: resolve(modRoot, `dto/${Camel}/update.dto.ts`),
+        content: renderer.render('dto-update', {
+            UpdateName,
+            CreateName,
+            writable: enhancedWritable,
+            picks: updatePicks,
+            typeArgs: updateTypeArgs || 'never',
+        }),
+    });
+    // Replace DTO
+    const replacePicks = enhancedWritable.map((f) => JSON.stringify(f.camel)).join(',\n  ');
+    resultFiles.push({
+        path: resolve(modRoot, `dto/${Camel}/replace.dto.ts`),
+        content: renderer.render('dto-replace', {
+            ReplaceName,
+            CreateName,
+            writable: enhancedWritable,
+            picks: replacePicks,
+        }),
+    });
+    // Query DTO
+    const queryPicks = enhancedFilterable.map((f) => JSON.stringify(f.camel)).join(',\n  ');
+    const queryTypeArgs = enhancedFilterable.map((f) => `'${f.camel}'`).join(' | ');
+    const sortEx = filterable[0] ? `${filterable[0]}:ASC,id:DESC` : 'id:DESC';
+    const filterEx = filterableArr
+        .slice(0, 2)
+        .map((f) => {
+        const isStr = /char|varchar|text/i.test(f.type);
+        return isStr ? `${f.camel}:like:a` : `${f.camel}:gte:10`;
+    })
+        .join(',');
+    const searchFields = searchable.join('/') || '无';
+    resultFiles.push({
+        path: resolve(modRoot, `dto/${Camel}/query.dto.ts`),
+        content: renderer.render('dto-query', {
+            QueryName,
+            CreateName,
+            filterable: enhancedFilterable,
+            picks: queryPicks,
+            typeArgs: queryTypeArgs || 'never',
+            sortDescription: '排序字段。标准格式：field:ASC 或 field:DESC；多字段用英文逗号分隔，或多次传 sort。示例：id:DESC、' + sortEx,
+            filterExample: filterEx || 'id:gte:1',
+            searchDescription: '搜索关键字，对可搜索字段（' + searchFields + '）模糊匹配',
+        }),
+    });
+    // DTO index
+    resultFiles.push({
+        path: resolve(modRoot, `dto/${Camel}/index.ts`),
+        content: renderer.render('dto-index', {}),
+    });
+    // Single VO
+    const allVoFields = [...(originalPkInfo ? [originalPkInfo] : []), ...entityFields].map((f) => enhanceField(f));
+    const voHasTransform = allVoFields.some((f) => f.isDate || f.isSensitive);
+    resultFiles.push({
+        path: resolve(modRoot, `vo/${Camel}/${Camel}.vo.ts`),
+        content: renderer.render('vo-single', {
+            VOName,
+            fields: allVoFields,
+            hasTransform: voHasTransform,
+        }),
+    });
+    // List VO
+    resultFiles.push({
+        path: resolve(modRoot, `vo/${Camel}/${Camel}List.vo.ts`),
+        content: renderer.render('vo-list', {
+            ListVOName,
+            VOName,
+            Camel,
+        }),
+    });
+    // VO index
+    resultFiles.push({
+        path: resolve(modRoot, `vo/${Camel}/index.ts`),
+        content: renderer.render('vo-index', { Camel }),
+    });
+    // Service
+    resultFiles.push({
+        path: resolve(modRoot, `service/${Camel}.service.ts`),
+        content: renderer.render('service', {
+            ServiceName,
+            Pascal,
+            Camel,
+            ormInfo,
+        }),
+    });
+    // Controller
+    const sArr = (arr) => arr.map((x) => JSON.stringify(x)).join(', ');
+    const idField = pkCamel || 'id';
+    const defaultSort = searchable && searchable.length
+        ? `[{ field: ${JSON.stringify(sortable[0] || idField)}, order: 'DESC' }]`
+        : `[{ field: 'id', order: 'DESC' }]`;
+    resultFiles.push({
+        path: resolve(modRoot, `controller/${Camel}.controller.ts`),
+        content: renderer.render('controller', {
+            CtrlName, Pascal, ServiceName,
+            CreateName, UpdateName, ReplaceName, QueryName,
+            VOName, ListVOName,
+            Camel, pluralKebab, tagName, desc,
+            sortable: sArr(sortable),
+            filterable: sArr(filterable),
+            searchable: sArr(searchable),
+            pkCamel,
+            idField,
+            defaultSort,
+        }),
+    });
+    // Common VO
+    const commonVO = resolve(outputPath || baseSrcPath, 'framework/vo/crudPage.vo.ts');
+    resultFiles.push({
+        path: commonVO,
+        content: renderer.render('crud-page-vo', {}),
+        createOnly: true,
+    });
+    return { files: resultFiles, Pascal, pluralKebab, Camel, sortable, filterable, searchable };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { loadConfig, mergeConfigs } from './config.js';
+export { detectOrm } from './orm.js';
+export { getDbConfigFromProject, resolveDefaultDbName, getTableFieldsFromDb, templateFieldsFor, } from './db.js';
+export { buildFiles } from './generator.js';
+export { TemplateRenderer, createRenderer } from './renderer.js';
+export type { TemplateName, TemplateRendererOptions } from './renderer.js';
+export { runCli } from './cli.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { loadConfig, mergeConfigs } from './config.js';
+export { detectOrm } from './orm.js';
+export { getDbConfigFromProject, resolveDefaultDbName, getTableFieldsFromDb, templateFieldsFor, } from './db.js';
+export { buildFiles } from './generator.js';
+export { TemplateRenderer, createRenderer } from './renderer.js';
+export { runCli } from './cli.js';
+export * from './types.js';

package/dist/orm.d.ts

@@ -0,0 +1,2 @@
+import type { OrmInfo } from './types.js';
+export declare function detectOrm(baseSrcPath: string): OrmInfo;

package/dist/orm.js

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+export function detectOrm(baseSrcPath) {
+    const pkgFile = resolve(baseSrcPath, '../package.json');
+    const deps = {};
+    if (existsSync(pkgFile)) {
+        const raw = readFileSync(pkgFile, 'utf-8').replace(/^\uFEFF/, '');
+        const p = JSON.parse(raw);
+        for (const k of Object.keys(p.dependencies || {}))
+            deps[k] = p.dependencies[k];
+        for (const k of Object.keys(p.devDependencies || {}))
+            deps[k] = p.devDependencies[k];
+    }
+    if (deps['@midwayjs/typeorm'] || deps.typeorm) {
+        return {
+            orm: 'typeorm',
+            ormSuffix: 'entity',
+            serviceParent: 'TypeOrmCrudService',
+            importCrudOrm: `from '@midwayjs/crud/typeorm'`,
+            injectEntity: '@InjectEntityModel',
+        };
+    }
+    if (deps['@midwayjs/sequelize'] || deps.sequelize) {
+        return {
+            orm: 'sequelize',
+            ormSuffix: 'model',
+            serviceParent: 'SequelizeCrudService',
+            importCrudOrm: `from '@midwayjs/crud/sequelize'`,
+            injectEntity: '@InjectModel',
+        };
+    }
+    if (deps['@midwayjs/mikro'] || deps['@mikro-orm/core']) {
+        return {
+            orm: 'mikro',
+            ormSuffix: 'entity',
+            serviceParent: 'MikroCrudService',
+            importCrudOrm: `from '@midwayjs/crud/mikro'`,
+            injectEntity: '@InjectRepository',
+        };
+    }
+    if (deps['@midwayjs/mongoose'] || deps.mongoose) {
+        return {
+            orm: 'mongoose',
+            ormSuffix: 'schema',
+            serviceParent: 'MongooseCrudService',
+            importCrudOrm: `from '@midwayjs/crud/mongoose'`,
+            injectEntity: '@InjectModel',
+        };
+    }
+    return {
+        orm: 'typeorm',
+        ormSuffix: 'entity',
+        serviceParent: 'TypeOrmCrudService',
+        importCrudOrm: `from '@midwayjs/crud/typeorm'`,
+        injectEntity: '@InjectEntityModel',
+    };
+}

package/dist/renderer.d.ts

@@ -0,0 +1,14 @@
+export type TemplateName = 'entity' | 'dto-create' | 'dto-update' | 'dto-replace' | 'dto-query' | 'dto-index' | 'vo-single' | 'vo-list' | 'vo-index' | 'service' | 'controller' | 'crud-page-vo';
+export interface TemplateRendererOptions {
+    customTemplatesPath?: string;
+}
+export declare class TemplateRenderer {
+    private env;
+    private customTemplatesPath?;
+    constructor(options?: TemplateRendererOptions);
+    render(templateName: TemplateName, context: Record<string, any>): string;
+    hasCustomTemplate(templateName: TemplateName): boolean;
+    getDefaultTemplatesDir(): string;
+    getCustomTemplatesDir(): string | undefined;
+}
+export declare function createRenderer(options?: TemplateRendererOptions): TemplateRenderer;

package/dist/renderer.js

@@ -0,0 +1,62 @@
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import nunjucks from 'nunjucks';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DEFAULT_TEMPLATES_DIR = resolve(__dirname, '..', 'templates');
+const TEMPLATE_FILES = {
+    entity: 'entity.njk',
+    'dto-create': 'dto-create.njk',
+    'dto-update': 'dto-update.njk',
+    'dto-replace': 'dto-replace.njk',
+    'dto-query': 'dto-query.njk',
+    'dto-index': 'dto-index.njk',
+    'vo-single': 'vo-single.njk',
+    'vo-list': 'vo-list.njk',
+    'vo-index': 'vo-index.njk',
+    service: 'service.njk',
+    controller: 'controller.njk',
+    'crud-page-vo': 'crud-page-vo.njk',
+};
+export class TemplateRenderer {
+    env;
+    customTemplatesPath;
+    constructor(options = {}) {
+        this.customTemplatesPath = options.customTemplatesPath;
+        const searchPaths = [];
+        if (this.customTemplatesPath && existsSync(this.customTemplatesPath)) {
+            searchPaths.push(this.customTemplatesPath);
+        }
+        searchPaths.push(DEFAULT_TEMPLATES_DIR);
+        this.env = new nunjucks.Environment(searchPaths.map((p) => new nunjucks.FileSystemLoader(p)), {
+            autoescape: false,
+            throwOnUndefined: false,
+            trimBlocks: false,
+            lstripBlocks: false,
+        });
+        this.env.addFilter('json', (value) => JSON.stringify(value));
+    }
+    render(templateName, context) {
+        const templateFile = TEMPLATE_FILES[templateName];
+        if (!templateFile) {
+            throw new Error(`Unknown template: ${templateName}`);
+        }
+        return this.env.render(templateFile, context);
+    }
+    hasCustomTemplate(templateName) {
+        if (!this.customTemplatesPath)
+            return false;
+        const templateFile = TEMPLATE_FILES[templateName];
+        return existsSync(resolve(this.customTemplatesPath, templateFile));
+    }
+    getDefaultTemplatesDir() {
+        return DEFAULT_TEMPLATES_DIR;
+    }
+    getCustomTemplatesDir() {
+        return this.customTemplatesPath;
+    }
+}
+export function createRenderer(options = {}) {
+    return new TemplateRenderer(options);
+}

package/dist/templates.d.ts

@@ -0,0 +1,70 @@
+import type { FieldInfo, OrmInfo } from './types.js';
+export declare function entityTemplate(params: {
+    orm: string;
+    ormSuffix: string;
+    fields: FieldInfo[];
+    tableName: string;
+    Pascal: string;
+    Camel: string;
+    originalPkInfo?: FieldInfo | null;
+    hasPk: boolean;
+}): string;
+export declare function createDtoTemplate(params: {
+    CreateName: string;
+    Pascal: string;
+    createFields: FieldInfo[];
+}): string;
+export declare function updateDtoTemplate(params: {
+    UpdateName: string;
+    CreateName: string;
+    writable: FieldInfo[];
+    Camel: string;
+    Pascal: string;
+}): string;
+export declare function replaceDtoTemplate(params: {
+    ReplaceName: string;
+    CreateName: string;
+    writable: FieldInfo[];
+}): string;
+export declare function queryDtoTemplate(params: {
+    QueryName: string;
+    CreateName: string;
+    filterable: FieldInfo[];
+}): string;
+export declare function singleVOTemplate(params: {
+    VOName: string;
+    Pascal: string;
+    Camel: string;
+    fields: FieldInfo[];
+}): string;
+export declare function listVOTemplate(params: {
+    ListVOName: string;
+    VOName: string;
+    Camel: string;
+}): string;
+export declare function crudPageCommonTemplate(): string;
+export declare function serviceTemplate(params: {
+    ServiceName: string;
+    Pascal: string;
+    Camel: string;
+    ormInfo: OrmInfo;
+}): string;
+export declare function controllerTemplate(params: {
+    CtrlName: string;
+    Pascal: string;
+    ServiceName: string;
+    CreateName: string;
+    UpdateName: string;
+    ReplaceName: string;
+    QueryName: string;
+    VOName: string;
+    ListVOName: string;
+    Camel: string;
+    pluralKebab: string;
+    tagName: string;
+    desc: string;
+    sortable: string[];
+    filterable: string[];
+    searchable: string[];
+    pkCamel: string;
+}): string;