@mingfuyun/star-allinone 0.2.0 → 0.3.0

package/scripts/gen/page.js

@@ -0,0 +1,483 @@
+const fs = require('fs');
+const path = require('path');
+const { toPascal, parseOperationSelector } = require('./names');
+const { generateService } = require('./service');
+const { loadProject, writeFile } = require('./project');
+
+function detectLayout(root) {
+  const hasPageContainer = fs.existsSync(path.join(root, 'src/components/PageContainer/index.tsx'));
+  const hasProTableLess = fs.existsSync(path.join(root, 'src/styles/proTable.less'));
+  const hasContainerConfig = fs.existsSync(path.join(root, 'src/components/Page/Container/config.tsx'));
+  return { hasPageContainer, hasProTableLess, hasContainerConfig };
+}
+
+function featureNames(options) {
+  const feature = options.feature.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+  if (!feature) throw new Error('Missing --feature. Example: --feature Widgets');
+  const parts = feature.split('/');
+  const leaf = toPascal(parts[parts.length - 1]);
+  const dir = [...parts.slice(0, -1), leaf].join('/');
+  return {
+    featurePath: dir,
+    leaf,
+    component: `./${dir}`,
+    drawer: `${leaf}Drawer`,
+    confirm: `${leaf}ConfirmModal`,
+    title: options.title || leaf,
+    route: options.route || `/${leaf.replace(/[A-Z]/g, (ch, i) => (i ? '-' : '') + ch.toLowerCase())}`,
+  };
+}
+
+function columnFields(itemTypeSource = '') {
+  const fields = [...itemTypeSource.matchAll(/^\s+(\w+)\??:/gm)].map((match) => match[1]);
+  const preferred = fields.filter((name) => !['created_at', 'updated_at', 'createTime', 'updateTime'].includes(name));
+  return (preferred.length ? preferred : fields).slice(0, 6);
+}
+
+function emitColumns(names, itemType, fields, permissions) {
+  const columns = fields.map((field, index) => {
+    const search = index < 2;
+    return `  {
+    title: '${field}',
+    dataIndex: '${field}',
+    key: '${field}',
+    hideInSearch: ${search ? 'false' : 'true'},
+    ellipsis: true,
+    render: (_, record) => record.${field} ?? '-',
+  }`;
+  });
+  if (!columns.length) {
+    columns.push(`  {
+    title: 'ID',
+    dataIndex: 'id',
+    key: 'id',
+    hideInSearch: true,
+  }`);
+  }
+  const permCreate = permissions.create ? `      permission: '${permissions.create}',\n` : '';
+  const permEdit = permissions.edit ? `      permission: '${permissions.edit}',\n` : '';
+  const permDelete = permissions.delete ? `      permission: '${permissions.delete}',\n` : '';
+  return `import type {
+  ITableProps,
+  TableSearchType,
+} from '@/components/CommonTable/type';
+import type { ProColumns } from '@ant-design/pro-components';
+
+type Handlers = {
+  handleEdit: (record: ${itemType}) => void;
+  handleDelete: (record: ${itemType}) => void;
+};
+
+type ToolbarHandlers = { handleCreate: () => void };
+
+export const columns = (): ProColumns<${itemType}>[] => [
+${columns.join(',\n')},
+];
+
+export const getActionColumn = ({
+  handleEdit,
+  handleDelete,
+}: Handlers): NonNullable<
+  ITableProps<${itemType}>['actionColumn']
+>['actions'] => [
+  {
+    key: 'edit',
+${permEdit}    getText: () => '编辑',
+    onClick: handleEdit,
+  },
+  {
+    key: 'delete',
+${permDelete}    getText: () => '删除',
+    onClick: handleDelete,
+  },
+];
+
+export const getToolBarRender = ({
+  handleCreate,
+}: ToolbarHandlers): TableSearchType[] => [
+  {
+    key: 'create',
+    text: '新增',
+    type: 'primary',
+${permCreate}    onClick: handleCreate,
+  },
+];
+`;
+}
+
+function emitIndex(names, layout, types, fns, pagination) {
+  const pageImport = layout.hasPageContainer
+    ? `import PageContainer from '@/components/PageContainer';\n`
+    : '';
+  const open = layout.hasPageContainer
+    ? `    <PageContainer header={{ title: undefined }}>`
+    : '    <>';
+  const close = layout.hasPageContainer ? `    </PageContainer>` : '    </>';
+  const listAccess = pagination === 'results-count'
+    ? 'list: data?.results || [],\n          total: data?.count || 0,'
+    : 'list: data?.list || [],\n          total: data?.total || 0,';
+  const queryType = types.queryType || 'Record<string, unknown>';
+  const itemType = types.itemType || 'Record<string, unknown>';
+  const listFn = fns.list || `list${names.leaf}`;
+  const deleteCall = fns.remove
+    ? `        await Service.${fns.remove}(record.id);`
+    : `        // TODO: call delete service`;
+  const rowKey = 'id';
+  return `import MFProTable from '@/components/CommonTable/MFProTable';
+import type { MFTableRef } from '@/components/CommonTable/type';
+${pageImport}import Service from '@/services';
+import { message } from 'antd';
+import { useCallback, useRef } from 'react';
+import ${names.confirm}, {
+  type ${names.confirm}Ref,
+} from './components/${names.confirm}';
+import ${names.drawer}, {
+  type ${names.drawer}Ref,
+} from './components/${names.drawer}';
+import { columns, getActionColumn, getToolBarRender } from './const';
+import styles from './index.less';
+
+export default function ${names.leaf}() {
+  const tableRef = useRef<MFTableRef>(null);
+  const drawerRef = useRef<${names.drawer}Ref>(null);
+  const confirmRef = useRef<${names.confirm}Ref>(null);
+
+  const fetchData = useCallback(async (params: ${queryType}) => {
+    try {
+      const { data } = await Service.${listFn}(params);
+      return {
+        code: 0,
+        data: {
+          ${listAccess}
+        },
+      };
+    } catch (error) {
+      console.error('获取${names.title}失败:', error);
+      return {
+        code: 0,
+        data: {
+          list: [],
+          total: 0,
+        },
+      };
+    }
+  }, []);
+
+  const handleCreate = () => {
+    drawerRef.current?.show();
+  };
+
+  const handleEdit = (record: ${itemType}) => {
+    drawerRef.current?.show({ record });
+  };
+
+  const handleDelete = (record: ${itemType}) => {
+    confirmRef.current?.show({
+      title: \`确定删除该记录吗？\`,
+      onConfirm: async () => {
+${deleteCall}
+        message.success('删除成功');
+        tableRef.current?.reload();
+      },
+    });
+  };
+
+  return (
+${open}
+      <div className={styles.page}>
+        <MFProTable<${itemType}, ${queryType}>
+          ref={tableRef}
+          actionColumn={{
+            actions: getActionColumn({ handleEdit, handleDelete }),
+          }}
+          bordered
+          columns={columns()}
+          fetchData={fetchData}
+          queryParams={{}}
+          rowKey="${rowKey}"
+          scroll={{ x: 'max-content' }}
+          topTitle={false}
+          toolBarRender={getToolBarRender({ handleCreate })}
+        />
+      </div>
+      <${names.drawer} ref={drawerRef} reload={() => tableRef.current?.reload()} />
+      <${names.confirm} ref={confirmRef} />
+${close}
+  );
+}
+`;
+}
+
+function emitLess(layout) {
+  if (layout.hasProTableLess) {
+    return `@import '@/styles/proTable.less';
+
+.page {
+  min-width: 0;
+  .pro-table-page(false, false);
+}
+`;
+  }
+  return `.page {
+  min-width: 0;
+}
+`;
+}
+
+function emitDrawer(names, types, fns) {
+  const itemType = types.itemType || 'Record<string, unknown>';
+  const createCall = fns.create
+    ? `        await Service.${fns.create}(values);`
+    : '        // TODO: call create service';
+  const updateCall = fns.update
+    ? `        await Service.${fns.update}(record.id, values);`
+    : '        // TODO: call update service';
+  return `import Service from '@/services';
+import { ProForm, ProFormText } from '@ant-design/pro-components';
+import { CustomDrawer, HocModal } from '@mingfuyun/star-allinone';
+import { Form, message } from 'antd';
+import { useEffect, useState } from 'react';
+
+type ${names.drawer}Args = {
+  record?: ${itemType};
+};
+
+type Props = ${names.drawer}Args & {
+  visible: boolean;
+  handleCancel: () => void;
+  reload: () => void;
+};
+
+export interface ${names.drawer}Ref {
+  show: (args?: ${names.drawer}Args) => void;
+  hide: () => void;
+}
+
+const ${names.drawer}: React.FC<Props> = ({
+  visible,
+  handleCancel,
+  record,
+  reload,
+}) => {
+  const [form] = Form.useForm();
+  const [loading, setLoading] = useState(false);
+  const editing = Boolean(record);
+
+  useEffect(() => {
+    if (!visible) return;
+    form.resetFields();
+    if (record) form.setFieldsValue(record);
+  }, [form, record, visible]);
+
+  const handleConfirm = async () => {
+    try {
+      const values = await form.validateFields();
+      setLoading(true);
+      if (editing && record) {
+${updateCall}
+      } else {
+${createCall}
+      }
+      message.success(editing ? '编辑成功' : '新增成功');
+      reload();
+      handleCancel();
+    } catch (error) {
+      console.error('提交${names.title}失败:', error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <CustomDrawer
+      loading={loading}
+      open={visible}
+      title={editing ? '编辑${names.title}' : '新增${names.title}'}
+      width={480}
+      onClose={handleCancel}
+      onConfirm={handleConfirm}
+    >
+      <ProForm
+        form={form}
+        labelCol={{ flex: '88px' }}
+        layout="horizontal"
+        submitter={false}
+      >
+        <ProFormText
+          name="name"
+          label="名称"
+          placeholder="请输入名称"
+          rules={[{ required: true, message: '请输入名称' }]}
+        />
+      </ProForm>
+    </CustomDrawer>
+  );
+};
+
+export default HocModal(${names.drawer});
+`;
+}
+
+function emitConfirm(names) {
+  return `import { BaseModal, HocModal } from '@mingfuyun/star-allinone';
+import { Typography } from 'antd';
+import { useState } from 'react';
+
+export type ${names.confirm}Args = {
+  title: string;
+  content?: React.ReactNode;
+  onConfirm: () => Promise<void>;
+};
+
+type Props = ${names.confirm}Args & {
+  visible: boolean;
+  handleCancel: () => void;
+};
+
+export interface ${names.confirm}Ref {
+  show: (args: ${names.confirm}Args) => void;
+  hide: () => void;
+}
+
+const ${names.confirm}: React.FC<Props> = ({
+  visible,
+  handleCancel,
+  title,
+  content,
+  onConfirm,
+}) => {
+  const [loading, setLoading] = useState(false);
+
+  const handleOk = async () => {
+    setLoading(true);
+    try {
+      await onConfirm();
+      handleCancel();
+    } catch (error) {
+      console.error('确认操作失败:', error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <BaseModal
+      confirmLoading={loading}
+      destroyOnClose
+      maskClosable={false}
+      title={title}
+      visible={visible}
+      width={480}
+      onCancel={handleCancel}
+      onOk={handleOk}
+    >
+      <Typography.Paragraph style={{ marginBottom: 0 }}>
+        {content || '操作提交后将立即生效，请确认是否继续。'}
+      </Typography.Paragraph>
+    </BaseModal>
+  );
+};
+
+export default HocModal(${names.confirm});
+`;
+}
+
+function patchRoute(root, names, dryRun) {
+  const file = path.join(root, 'config/route.ts');
+  if (!fs.existsSync(file)) {
+    throw new Error('Missing config/route.ts');
+  }
+  const current = fs.readFileSync(file, 'utf8');
+  if (current.includes(`path: '${names.route}'`) || current.includes(`path: "${names.route}"`)) {
+    console.log(`route already has ${names.route}`);
+    return;
+  }
+  const snippet = `  {
+    name: '${names.title}',
+    path: '${names.route}',
+    component: '${names.component}',
+  },
+`;
+  let next = current;
+  if (current.includes("path: '/*'") || current.includes('path: "/*"')) {
+    next = current.replace(/\{\s*path:\s*['"]\/\*['"]/, `${snippet}  $&`);
+  } else {
+    next = current.replace(/\];\s*$/, `${snippet}];\n`);
+  }
+  writeFile(file, next, dryRun);
+}
+
+function generatePage(cwd, options) {
+  const operations = [
+    ['list', options.listOperation],
+    ['create', options.createOperation],
+    ['update', options.updateOperation],
+    ['remove', options.deleteOperation],
+  ].filter(([, value]) => value);
+
+  const project = loadProject(cwd, {
+    ...options,
+    requireSpec: operations.length > 0,
+  });
+  const names = featureNames(options);
+  const layout = detectLayout(project.root);
+  const pageDir = path.join(project.root, 'src/pages', names.featurePath);
+  const files = [
+    path.join(pageDir, 'index.tsx'),
+    path.join(pageDir, 'index.less'),
+    path.join(pageDir, 'const.tsx'),
+    path.join(pageDir, 'components', `${names.drawer}.tsx`),
+    path.join(pageDir, 'components', `${names.confirm}.tsx`),
+  ];
+  const exists = files.filter((file) => fs.existsSync(file));
+  if (exists.length) {
+    throw new Error(`Refusing to overwrite existing page files:\n${exists.map((file) => path.relative(project.root, file)).join('\n')}`);
+  }
+
+  const fns = {};
+  let types = { itemType: `${toPascal(names.leaf)}_API.${names.leaf}Item`, queryType: undefined };
+  let pagination = 'list-total';
+  let itemSource = '';
+
+  for (const [key, selector] of operations) {
+    const result = generateService(cwd, {
+      ...options,
+      operation: selector,
+      mockFile: false,
+    });
+    fns[key] = result.fn;
+    if (key === 'list') {
+      types = {
+        itemType: result.itemType || types.itemType,
+        queryType: result.queryType,
+      };
+      pagination = result.pagination || pagination;
+      itemSource = result.nextTypings || '';
+      if (result.status === 'reuse' && result.typingsPath && fs.existsSync(result.typingsPath)) {
+        itemSource = fs.readFileSync(result.typingsPath, 'utf8');
+      }
+    }
+  }
+
+  const fields = columnFields(itemSource);
+  const permissions = {
+    create: options.permissionCreate,
+    edit: options.permissionEdit,
+    delete: options.permissionDelete,
+  };
+
+  writeFile(files[0], emitIndex(names, layout, types, fns, pagination), project.dryRun);
+  writeFile(files[1], emitLess(layout), project.dryRun);
+  writeFile(files[2], emitColumns(names, types.itemType, fields, permissions), project.dryRun);
+  writeFile(files[3], emitDrawer(names, types, fns), project.dryRun);
+  writeFile(files[4], emitConfirm(names), project.dryRun);
+  patchRoute(project.root, names, project.dryRun);
+
+  if (layout.hasContainerConfig) {
+    console.log(`starscope-style tab container detected. Register ${names.featurePath} in src/components/Page/Container/config.tsx if this page should appear as a tab.`);
+  }
+  console.log(`${project.dryRun ? '[dry-run] ' : ''}generated page ${names.route} -> src/pages/${names.featurePath}`);
+  return names;
+}
+
+module.exports = { generatePage, featureNames };

package/scripts/gen/project.js

@@ -0,0 +1,154 @@
+const fs = require('fs');
+const path = require('path');
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function findProjectRoot(start) {
+  let current = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(current, '.star-allinone.json'))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error('Missing .star-allinone.json. Run this command from a business project root.');
+    }
+    current = parent;
+  }
+}
+
+function loadProject(cwd, options = {}) {
+  const root = findProjectRoot(cwd);
+  const config = readJson(path.join(root, '.star-allinone.json'));
+  const specPath = options.spec || config.openapi
+    ? path.resolve(root, options.spec || config.openapi)
+    : '';
+  if (options.requireSpec !== false && !specPath) {
+    throw new Error('Set openapi in .star-allinone.json or pass --spec <file>.');
+  }
+  if (specPath && !fs.existsSync(specPath)) {
+    throw new Error(`OpenAPI file not found: ${specPath}`);
+  }
+  return {
+    root,
+    config,
+    specPath,
+    spec: specPath ? readJson(specPath) : null,
+    serviceDir: path.resolve(root, config.serviceDir || 'src/services'),
+    dryRun: Boolean(options.dryRun),
+  };
+}
+
+function listDomainDirs(serviceDir) {
+  if (!fs.existsSync(serviceDir)) return [];
+  return fs.readdirSync(serviceDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+}
+
+function existingRequestFile(serviceDir) {
+  for (const name of ['request.tsx', 'request.ts']) {
+    const file = path.join(serviceDir, name);
+    if (fs.existsSync(file)) return name.replace(/\.(tsx|ts)$/, '');
+  }
+  return 'request';
+}
+
+function writeFile(file, content, dryRun) {
+  if (dryRun) {
+    console.log(`[dry-run] write ${file}`);
+    return;
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content.endsWith('\n') ? content : `${content}\n`);
+}
+
+function typeExists(content, typeName) {
+  return new RegExp(`\\btype\\s+${typeName}\\b`).test(content);
+}
+
+function insertTypes(content, namespace, blocks) {
+  if (!blocks.length) return content;
+  const nsRe = new RegExp(`declare namespace ${namespace}\\s*\\{`);
+  if (!nsRe.test(content)) {
+    const extra = `declare namespace ${namespace} {\n${blocks.join('\n\n')}\n}\n`;
+    return content.trim() ? `${content.trim()}\n\n${extra}` : extra;
+  }
+  const lastBrace = content.lastIndexOf('}');
+  if (lastBrace === -1) throw new Error(`Cannot insert types into ${namespace}`);
+  return `${content.slice(0, lastBrace).replace(/\s*$/, '\n')}${blocks.join('\n\n')}\n${content.slice(lastBrace)}`;
+}
+
+function insertMethods(content, methods, exportNames, requestImport) {
+  let next = content;
+  if (!next.includes("from '../request'") && !next.includes('from "../request"')) {
+    next = `import MFRequest from '../${requestImport}';\n${next}`;
+  }
+  const exportMatch = next.match(/export default \{[\s\S]*?\};?/);
+  if (!exportMatch) {
+    return `${next.trim()}\n\n${methods.join('\n\n')}\n\nexport default {\n${exportNames.map((name) => `  ${name},`).join('\n')}\n};\n`;
+  }
+  const insertAt = exportMatch.index;
+  const before = next.slice(0, insertAt).replace(/\s*$/, '\n\n');
+  const exportBlock = exportMatch[0];
+  const namesToAdd = exportNames.filter((name) => !new RegExp(`\\b${name}\\b`).test(exportBlock));
+  let updatedExport = exportBlock;
+  if (namesToAdd.length) {
+    updatedExport = exportBlock.replace(
+      /export default \{/,
+      `export default {\n${namesToAdd.map((name) => `  ${name},`).join('\n')}`,
+    );
+  }
+  return `${before}${methods.join('\n\n')}\n\n${updatedExport}${next.slice(insertAt + exportBlock.length)}`;
+}
+
+function patchServiceIndex(indexFile, domain, serviceFile, dryRun) {
+  const importName = `${toCamelSafe(domain)}API`;
+  const importLine = `import ${importName} from './${domain}/${serviceFile}';`;
+  const spread = `...${importName},`;
+  if (!fs.existsSync(indexFile)) {
+    writeFile(
+      indexFile,
+      `${importLine}\n\nexport default {\n  ${spread}\n};\n`,
+      dryRun,
+    );
+    return;
+  }
+  const current = fs.readFileSync(indexFile, 'utf8');
+  if (current.includes(`'./${domain}/${serviceFile}'`) || current.includes(`"./${domain}/${serviceFile}"`)) {
+    return;
+  }
+  let next = `${importLine}\n${current}`;
+  if (/export default \{/.test(next) && !next.includes(spread)) {
+    next = next.replace(/export default \{/, `export default {\n  ${spread}`);
+  }
+  writeFile(indexFile, next, dryRun);
+}
+
+function toCamelSafe(domain) {
+  return domain.charAt(0).toLowerCase() + domain.slice(1);
+}
+
+function patchRootTypings(root, domain, dryRun) {
+  const file = path.join(root, 'typings.d.ts');
+  if (!fs.existsSync(file)) return;
+  const ref = `/// <reference path="./src/services/${domain}/typings.d.ts" />`;
+  const current = fs.readFileSync(file, 'utf8');
+  if (current.includes(`src/services/${domain}/typings.d.ts`)) return;
+  if (!current.includes('/// <reference path=')) return;
+  writeFile(file, `${ref}\n${current}`, dryRun);
+}
+
+module.exports = {
+  readJson,
+  findProjectRoot,
+  loadProject,
+  listDomainDirs,
+  existingRequestFile,
+  writeFile,
+  typeExists,
+  insertTypes,
+  insertMethods,
+  patchServiceIndex,
+  patchRootTypings,
+};