@mingfuyun/star-allinone 0.2.0 → 0.3.1

package/scripts/gen/names.js

@@ -0,0 +1,117 @@
+function toPascal(value) {
+  return String(value || '')
+    .replace(/[^\w]+/g, ' ')
+    .split(/[\s_-]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function toCamel(value) {
+  const pascal = toPascal(value);
+  return pascal ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : '';
+}
+
+function toNamespace(domain) {
+  return `${String(domain)
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^\w]+/g, '_')
+    .replace(/_+/g, '_')
+    .toUpperCase()}_API`;
+}
+
+function toServiceFile(domain) {
+  return toCamel(domain);
+}
+
+function normalizePath(apiPath) {
+  if (!apiPath) return '/';
+  const withSlash = apiPath.startsWith('/') ? apiPath : `/${apiPath}`;
+  return withSlash.replace(/\/{2,}/g, '/');
+}
+
+function pathVariants(apiPath) {
+  const normalized = normalizePath(apiPath);
+  const trimmed = normalized.replace(/\/+$/, '') || '/';
+  const withSlash = trimmed === '/' ? '/' : `${trimmed}/`;
+  return [...new Set([normalized, trimmed, withSlash])];
+}
+
+function pathParamsFromPath(apiPath) {
+  return [...String(apiPath).matchAll(/\{([^}]+)\}/g)].map((match) => match[1]);
+}
+
+function pathToTemplate(apiPath) {
+  const replaced = normalizePath(apiPath).replace(/\{([^}]+)\}/g, '${$1}');
+  return replaced.includes('${') ? `\`${replaced}\`` : `'${replaced}'`;
+}
+
+function parseOperationSelector(raw) {
+  const value = String(raw || '').trim();
+  if (!value) throw new Error('Missing --operation. Example: GET /api/v1/devices/');
+  const operationId = value.match(/^operationId\s*:\s*(.+)$/i);
+  if (operationId) return { operationId: operationId[1].trim() };
+  const spaced = value.match(/^(GET|POST|PUT|PATCH|DELETE)\s+(\/\S+)/i);
+  if (spaced) {
+    return { method: spaced[1].toLowerCase(), path: spaced[2] };
+  }
+  if (value.startsWith('/')) return { path: value };
+  return { operationId: value };
+}
+
+function functionName(operation) {
+  if (operation.operationId) return toCamel(operation.operationId);
+  const params = pathParamsFromPath(operation.path);
+  const segments = normalizePath(operation.path)
+    .replace(/\{[^}]+\}/g, '')
+    .split('/')
+    .filter(Boolean);
+  const resource = toPascal(segments[segments.length - 1] || 'Resource');
+  const method = operation.method.toLowerCase();
+  if (method === 'get' && params.length) return `get${resource}Detail`;
+  if (method === 'get') return `list${resource}`;
+  if (method === 'post') return `create${resource}`;
+  if (method === 'patch' || method === 'put') return `update${resource}`;
+  if (method === 'delete') return `delete${resource}`;
+  return toCamel(`${method}_${resource}`);
+}
+
+function requestHelper(operation) {
+  const method = operation.method.toLowerCase();
+  const contentType = operation.contentType || '';
+  if (method === 'get' && /export|download/.test(operation.path)) return 'export';
+  if (contentType.includes('multipart')) return 'import';
+  if (method === 'get') return 'get';
+  if (method === 'post') return 'post';
+  if (method === 'patch') return 'patch';
+  if (method === 'put') return 'put';
+  if (method === 'delete') return 'delete';
+  return method;
+}
+
+function domainFromPath(apiPath) {
+  const segments = normalizePath(apiPath).split('/').filter(Boolean);
+  const afterApi = segments[0] === 'api' ? segments.slice(2) : segments;
+  return toPascal(afterApi[0] || 'Common');
+}
+
+function typeName(prefix, suffix, useIPrefix) {
+  const name = `${toPascal(prefix)}${toPascal(suffix)}`;
+  return useIPrefix ? `I${name}` : name;
+}
+
+module.exports = {
+  toPascal,
+  toCamel,
+  toNamespace,
+  toServiceFile,
+  normalizePath,
+  pathVariants,
+  pathParamsFromPath,
+  pathToTemplate,
+  parseOperationSelector,
+  functionName,
+  requestHelper,
+  domainFromPath,
+  typeName,
+};

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 };