@mtpc/codegen

# 使用 pnpm（推荐）
pnpm add @mtpc/codegen @mtpc/core -D
 
# 或使用 npm
npm install @mtpc/codegen @mtpc/core -D
 
# 或使用 yarn
yarn add @mtpc/codegen @mtpc/core -D

import { Codegen } from '@mtpc/codegen';

import { createCodegen, generate } from '@mtpc/codegen';

interface CodegenOptions {
  /** 输出目录路径 */
  outputDir: string;
  /** 资源定义列表 */
  resources: ResourceDefinition[];
  /** 权限代码生成选项 */
  permissions?: PermissionOptions;
  /** TypeScript 类型生成选项 */
  typescript?: TypeScriptOptions;
  /** 元数据生成选项 */
  metadata?: MetadataOptions;
  /** 数据库 Schema 生成选项 */
  schema?: SchemaOptions;
}

# 生成代码（默认命令）
mtpc-codegen generate
 
# 初始化配置文件
mtpc-codegen init

# 基本使用
mtpc-codegen generate
 
# 指定输出目录
mtpc-codegen generate -o ./src/generated
 
# 预览（不写入文件）
mtpc-codegen generate --dry-run
 
# 清空后重新生成
mtpc-codegen generate --clean
 
# 使用自定义配置文件
mtpc-codegen generate -c ./mtpc.config.ts
 
# 初始化配置模板
mtpc-codegen init

import { createCodegen } from '@mtpc/codegen';
import { defineResource } from '@mtpc/core';
import { z } from 'zod';
 
// 定义资源
const userResource = defineResource({
  name: 'user',
  schema: z.object({
    id: z.string().uuid(),
    name: z.string().min(2).max(100),
    email: z.string().email(),
    role: z.enum(['admin', 'user', 'guest']),
  }),
  features: {
    create: true,
    read: true,
    update: true,
    delete: true,
    list: true,
  },
});
 
// 创建代码生成器
const codegen = createCodegen({
  outputDir: './src/generated',
  resources: [userResource],
  permissions: {
    format: 'const',
    prefix: 'APP_',
  },
  typescript: {
    includeZodSchemas: true,
  },
  schema: {
    enabled: true,
    dialect: 'postgresql', // 当前版本仅支持 PostgreSQL
    timestamps: true,
  },
});
 
// 生成并写入文件
const result = await codegen.generateAndWrite();
 
console.log(`Generated ${result.files.length} files`);

import { generate } from '@mtpc/codegen';
import { defineResource } from '@mtpc/core';
import { z } from 'zod';
 
const userResource = defineResource({
  name: 'user',
  schema: z.object({
    id: z.string().uuid(),
    name: z.string(),
  }),
  features: { create: true, read: true, update: true, delete: true },
});
 
// 一键生成（异步）
const result = await generate(
  [userResource],
  './src/generated',
  {
    permissions: { format: 'enum' },
    typescript: { includeZodSchemas: true },
    schema: { enabled: true },
  }
);
 
console.log(`Generated ${result.files.length} files`);

import { createCodegen } from '@mtpc/codegen';
 
const codegen = createCodegen({
  outputDir: './src/generated',
  resources: [],
});
 
// 链式添加资源
codegen
  .addResource(userResource)
  .addResource(postResource)
  .addResources([orderResource, productResource]);
 
await codegen.generateAndWrite({ clean: true });

import { z } from 'zod';
import { defineResource } from '@mtpc/core';
 
const userResource = defineResource({
  name: 'user',
  schema: z.object({
    id: z.string().uuid(),
    name: z.string().min(2),
    email: z.string().email(),
  }),
  features: { create: true, read: true, update: true, delete: true },
});
 
export const resources = [userResource];
export default { resources };

mtpc-codegen generate -c mtpc.config.ts

export const USER_CREATE = 'user:create' as const;
export const USER_READ = 'user:read' as const;
export const USER_UPDATE = 'user:update' as const;
export const USER_DELETE = 'user:delete' as const;
 
export const PERMISSIONS = {
  USER_CREATE: 'user:create',
  USER_READ: 'user:read',
  USER_UPDATE: 'user:update',
  USER_DELETE: 'user:delete',
} as const;
 
export type PermissionCode = typeof PERMISSIONS[keyof typeof PERMISSIONS];

export enum Permission {
  UserCreate = 'user:create',
  UserRead = 'user:read',
  UserUpdate = 'user:update',
  UserDelete = 'user:delete',
}

export const Permissions = {
  user: {
    create: 'user:create',
    read: 'user:read',
    update: 'user:update',
    delete: 'user:delete',
  },
} as const;

export type ResourceName = 'user' | 'post';
 
export type ResourceActions = {
  user: 'create' | 'read' | 'update' | 'delete';
  post: 'create' | 'read' | 'update' | 'delete';
};
 
export type PermissionCode<R extends ResourceName = ResourceName> =
  `${R}:${ResourceActions[R]}`;

import { z } from 'zod';
 
export const UserSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(2).max(100),
  email: z.string().email(),
  role: z.enum(['admin', 'user', 'guest']),
});
 
export type User = z.infer<typeof UserSchema>;
 
export type EntityTypes = {
  user: User;
  post: Post;
};

export interface ResourceMetadata {
  name: string;
  displayName: string;
  pluralName: string;
  description?: string;
  icon?: string;
  group?: string;
  hidden: boolean;
  features: {
    create: boolean;
    read: boolean;
    update: boolean;
    delete: boolean;
    list: boolean;
  };
  permissions: Array<{ code: string; action: string; description?: string }>;
  fields: Array<{ name: string; type: string; required: boolean }>;
}
 
export const resourceMetadata: Record<string, ResourceMetadata> = {
  user: {
    name: 'user',
    displayName: 'User',
    // ...
  },
};
 
export function getResourceMetadata(name: string): ResourceMetadata | undefined {
  return resourceMetadata[name];
}

import { pgTable, uuid, text, timestamp, index } from 'drizzle-orm/pg-core';
 
export const userTable = pgTable('users', {
  id: uuid('id').primaryKey().defaultRandom(),
  tenantId: uuid('tenant_id').notNull(),
  name: text('name').notNull(),
  email: text('email').notNull(),
  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
}, (table) => ({
  tenantIdx: index('users_tenant_idx').on(table.tenantId),
}));
 
export const tables = {
  user: userTable,
};

CREATE TABLE IF NOT EXISTS users (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID NOT NULL,
  name TEXT NOT NULL,
  email TEXT NOT NULL,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() NOT NULL,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() NOT NULL
);
 
CREATE INDEX IF NOT EXISTS users_tenant_idx ON users(tenant_id);

{
  "scripts": {
    "codegen": "mtpc-codegen generate",
    "build": "pnpm codegen && tsc",
    "dev": "pnpm codegen --watch && vite"
  }
}

steps:
  - name: Install dependencies
    run: pnpm install
 
  - name: Generate code
    run: pnpm codegen
 
  - name: Build
    run: pnpm build

src/
├── generated/          # 代码生成输出目录
│   ├── index.ts
│   ├── permissions.ts
│   ├── types.ts
│   ├── metadata.ts
│   └── schema.ts
├── resources/          # 资源定义
│   ├── user.ts
│   └── post.ts
└── mtpc.config.ts      # 配置文件

┌─────────────────────────────────────────┐
│         @mtpc/codegen                   │
│  ┌─────────┬─────────┬─────────────┐    │
│  │Permission│ TypeScript│ Schema │    │
│  │Generator │ Generator │Generator │    │
│  └─────────┴─────────┴─────────────┘    │
└────────────────┬────────────────────────┘
                 │ 生成
                 ▼
┌─────────────────────────────────────────┐
│         @mtpc/core                      │
│  ┌─────────────────────────────────┐    │
│  │     ResourceDefinition          │    │
│  │  (单一事实源 Single Source of   │    │
│  │   Truth)                        │    │
│  └─────────────────────────────────┘    │
└─────────────────────────────────────────┘

const resource = defineResource({
  name: 'user',
  schema: z.object({
    // ... 原有字段
    phone: z.string().optional(),  // 新增字段
  }),
});