create-meadminjs 1.0.0

package/template/meadmin/src/ruleType/string.ts

@@ -0,0 +1,29 @@
+import { RuleType } from '@midwayjs/validate';
+
+export interface CustomStringSchema<TSchema = string> extends RuleType.StringSchema<TSchema> {
+  /**
+   * 校验是否是正确的手机号
+   */
+  mobile(): this;
+}
+export const initRuleType = <T extends RuleType.Root>(customRuleType: T) => {
+  return customRuleType.extend((root) => ({
+    type: 'string',
+    base: root.string(),
+    messages: {
+      'string.mobile': '{{#label}} must be a true mobile',
+    },
+    rules: {
+      mobile: {
+        validate(value, helpers) {
+          if (!/^1\d{10}$/.test(value)) {
+            return helpers.error('string.mobile');
+          }
+          return value;
+        },
+      },
+    },
+  })) as {
+    string<TSchema = string>(): CustomStringSchema<TSchema>;
+  } & T;
+};

package/template/meadmin/src/service/dataSourceManager.service.ts

@@ -0,0 +1,55 @@
+import { Config, DataSourceManager, ILogger, Init, Inject, Logger, Provide, Scope, ScopeEnum } from '@midwayjs/core';
+import Sequelize from '@sequelize/core';
+
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class SequelizeDataSourceManagerService extends DataSourceManager<Sequelize> {
+  @Config('sequelize')
+  sequelizeConfig;
+
+  @Logger('coreLogger')
+  coreLogger: ILogger;
+
+  @Inject()
+  baseDir: string;
+
+  @Init()
+  async init() {
+    await this.initDataSource(this.sequelizeConfig, {
+      baseDir: this.baseDir,
+      entitiesConfigKey: 'models',
+    });
+  }
+
+  getName(): string {
+    return 'sequelize';
+  }
+
+  protected async createDataSource(config: any, dataSourceName: string): Promise<Sequelize> {
+    const client = new Sequelize(config);
+    const isConnected = await this.checkConnected(client);
+
+    if (isConnected && config.sync) {
+      await client.sync(config.syncOptions);
+    }
+
+    this.coreLogger.info('[midway:sequelize] client created: %s', dataSourceName);
+    return client;
+  }
+
+  protected async checkConnected(dataSource: Sequelize): Promise<boolean> {
+    try {
+      await dataSource.authenticate();
+      return true;
+    } catch (err) {
+      this.coreLogger.error(err);
+      return false;
+    }
+  }
+
+  protected async destroyDataSource(dataSource: Sequelize) {
+    if (await this.checkConnected(dataSource)) {
+      await dataSource.close();
+    }
+  }
+}

package/template/meadmin/src/service/response.service.ts

@@ -0,0 +1,65 @@
+import { CodeEunm } from '@/dict/code.enum.js';
+import { ApiErrorRes } from '@/response/apiError.res.js';
+import { ApiPageRes } from '@/response/apiPage.res.js';
+import { ApiSuccessRes } from '@/response/apiSuccess.res.js';
+import { Provide } from '@midwayjs/core';
+
+@Provide()
+// @Scope(ScopeEnum.Singleton)
+export class ResponseService {
+  /**
+   * 格式化返回函数
+   * @param code
+   * @param message
+   * @param data
+   * @returns
+   */
+  private response<C extends CodeEunm, T = any>(code: C, message: string, data: T) {
+    return {
+      code,
+      msg: message,
+      data,
+    };
+  }
+
+  /**
+   * 成功返回
+   * @param data
+   * @param message
+   * @returns
+   */
+  public success<T extends Record<string, any>>(data: T = {} as T, message: string): ApiSuccessRes<T> {
+    return this.response(CodeEunm.Success, message, data);
+  }
+
+  /**
+   * 失败返回
+   * @param message
+   * @param code
+   * @returns
+   */
+  public error(message: string, code: Exclude<CodeEunm, CodeEunm.Success>): ApiErrorRes {
+    return this.response(code, message, undefined);
+  }
+
+  /**
+   * 分页返回
+   * @param list
+   * @param total
+   * @param page
+   * @param pageSize
+   * @param message
+   * @returns
+   */
+  public successPage<T = any>(list: T[], total: number, page: number, pageSize: number, message: string): ApiPageRes<T> {
+    return this.success(
+      {
+        page,
+        pageSize,
+        total,
+        list,
+      },
+      message,
+    );
+  }
+}

package/template/meadmin/src/types/decorator.ts

@@ -0,0 +1,31 @@
+import { IMidwayApplication, IMidwayContainer, MidwayDecoratorService } from '@midwayjs/core';
+
+export interface RegistreDecorator {
+  /**
+   * 对象初始化时自动执行的方法
+   * @returns
+   */
+  init?(decoratorService: MidwayDecoratorService): Promise<void>;
+  /**
+   * 在应用配置加载后执行
+   */
+  onConfigLoad?(container: IMidwayContainer, app: IMidwayApplication): Promise<void>;
+
+  /**
+   * 在依赖注入容器 ready 的时候执行
+   */
+  onReady?(container: IMidwayContainer, app: IMidwayApplication): Promise<void>;
+  /**
+   * 在应用服务启动后执行
+   */
+  onServerReady?(container: IMidwayContainer, app: IMidwayApplication): Promise<void>;
+  /**
+   * 在应用停止的时候执行
+   */
+  onStop?(container: IMidwayContainer, app: IMidwayApplication): Promise<void>;
+
+  /**
+   * 在健康检查时执行
+   */
+  onHealthCheck?(container: IMidwayContainer): Promise<void>;
+}

package/template/meadmin/src/types/entity.ts

@@ -0,0 +1,209 @@
+import {
+  BelongsToCreateAssociationMixin,
+  BelongsToGetAssociationMixin,
+  BelongsToManyAddAssociationMixin,
+  BelongsToManyAddAssociationsMixin,
+  BelongsToManyCreateAssociationMixin,
+  BelongsToManyGetAssociationsMixin,
+  BelongsToManyHasAssociationMixin,
+  BelongsToManyHasAssociationsMixin,
+  BelongsToManySetAssociationsMixin,
+  BelongsToSetAssociationMixin,
+  CreationAttributes,
+  HasManyAddAssociationMixin,
+  HasManyAddAssociationsMixin,
+  HasManyCountAssociationsMixin,
+  HasManyCreateAssociationMixin,
+  HasManyGetAssociationsMixin,
+  HasManyHasAssociationMixin,
+  HasManyHasAssociationsMixin,
+  HasManyRemoveAssociationMixin,
+  HasManyRemoveAssociationsMixin,
+  HasManySetAssociationsMixin,
+  HasOneCreateAssociationMixin,
+  HasOneGetAssociationMixin,
+  HasOneSetAssociationMixin,
+  InferAttributesOptions,
+  Model,
+} from '@sequelize/core';
+import type { AnyFunction } from '@sequelize/utils';
+
+export type HasOneModel<
+  AssociationName extends string, //关联字段
+  T extends Model, //关联模型
+  ForeignKey extends keyof CreationAttributes<T> = never, //外键
+  K extends keyof T = 'id' extends keyof T ? 'id' : never, //关联模型主键key
+> = {
+  //获取关联信息
+  [Key in `get${Capitalize<AssociationName>}`]: HasOneGetAssociationMixin<T>;
+} & {
+  //设置关联信息
+  [Key in `set${Capitalize<AssociationName>}`]: HasOneSetAssociationMixin<T, T[K]>;
+} & {
+  //创建关联信息
+  [Key in `create${Capitalize<AssociationName>}`]: HasOneCreateAssociationMixin<T, ForeignKey>;
+};
+
+export type HasManyModel<
+  AssociationName extends string, //关联字段
+  SingularAssociationName extends string, //关联单数形式
+  PluralAssociationName extends string, //关联复数形式
+  T extends Model, //关联模型
+  ForeignKey extends keyof CreationAttributes<T> = never, //外键
+  K extends keyof T = 'id' extends keyof T ? 'id' : never, //关联模型主键key
+> = {
+  //获取关联信息
+  [Key in `get${Capitalize<AssociationName>}`]: HasManyGetAssociationsMixin<T>;
+} & {
+  //设置关联信息，添加新的关联之前删除旧的关联（多个）
+  [Key in `set${Capitalize<AssociationName>}`]: HasManySetAssociationsMixin<T, T[K]>;
+} & {
+  //添加新的关联关联信息，不删除旧的关联（单个）
+  [Key in `add${Capitalize<SingularAssociationName>}`]: HasManyAddAssociationMixin<T, T[K]>;
+} & {
+  //添加新的关联关联信息，不删除旧的关联（多个）
+  [Key in `add${Capitalize<PluralAssociationName>}`]: HasManyAddAssociationsMixin<T, T[K]>;
+} & {
+  //清除关联信息（单个）
+  [Key in `remove${Capitalize<SingularAssociationName>}`]: HasManyRemoveAssociationMixin<T, T[K]>;
+} & {
+  //清除关联信息（多个）
+  [Key in `remove${Capitalize<PluralAssociationName>}`]: HasManyRemoveAssociationsMixin<T, T[K]>;
+} & {
+  //关联创建器用于创建新的关联模型并将其与源模型关联
+  [Key in `create${Capitalize<AssociationName>}`]: HasManyCreateAssociationMixin<T, ForeignKey>;
+} & {
+  //检查是否关联（单个）
+  [Key in `has${Capitalize<SingularAssociationName>}`]: HasManyHasAssociationMixin<T, T[K]>;
+} & {
+  //检查是否关联（多个&关系）
+  [Key in `has${Capitalize<PluralAssociationName>}`]: HasManyHasAssociationsMixin<T, T[K]>;
+} & {
+  //统计关联模型数量
+  [Key in `counts${Capitalize<AssociationName>}`]: HasManyCountAssociationsMixin<T>;
+};
+
+export type BelongsToModel<
+  AssociationName extends string, //关联字段
+  T extends Model, //关联模型
+  K extends keyof T = 'id' extends keyof T ? 'id' : never, //关联模型主键key
+> = {
+  //获取关联信息
+  [Key in `get${Capitalize<AssociationName>}`]: BelongsToGetAssociationMixin<T>;
+} & {
+  //设置关联信息
+  [Key in `set${Capitalize<AssociationName>}`]: BelongsToSetAssociationMixin<T, T[K]>;
+} & {
+  //关联创建器用于创建新的关联模型并将其与源模型关联
+  [Key in `create${Capitalize<AssociationName>}`]: BelongsToCreateAssociationMixin<T>;
+};
+export type BelongsManyModel<
+  AssociationName extends string, //关联字段
+  SingularAssociationName extends string, //关联单数形式
+  PluralAssociationName extends string, //关联复数形式
+  T extends Model, //关联模型
+  K extends keyof T = 'id' extends keyof T ? 'id' : never, //关联模型主键key
+> = {
+  //获取关联信息
+  [Key in `get${Capitalize<AssociationName>}`]: BelongsToManyGetAssociationsMixin<T>;
+} & {
+  //设置关联信息，添加新的关联之前删除旧的关联（多个）
+  [Key in `set${Capitalize<AssociationName>}`]: BelongsToManySetAssociationsMixin<T, T[K]>;
+} & {
+  //添加新的关联关联信息，不删除旧的关联（单个）
+  [Key in `add${Capitalize<SingularAssociationName>}`]: BelongsToManyAddAssociationMixin<T, T[K]>;
+} & {
+  //添加新的关联关联信息，不删除旧的关联（多个）
+  [Key in `add${Capitalize<PluralAssociationName>}`]: BelongsToManyAddAssociationsMixin<T, T[K]>;
+} & {
+  //清除关联信息（单个）
+  [Key in `remove${Capitalize<SingularAssociationName>}`]: BelongsToManyAddAssociationsMixin<T, T[K]>;
+} & {
+  //清除关联信息（多个）
+  [Key in `remove${Capitalize<PluralAssociationName>}`]: BelongsToManyAddAssociationsMixin<T, T[K]>;
+} & {
+  //关联创建器用于创建新的关联模型并将其与源模型关联
+  [Key in `create${Capitalize<AssociationName>}`]: BelongsToManyCreateAssociationMixin<T>;
+} & {
+  //检查是否关联（单个）
+  [Key in `has${Capitalize<SingularAssociationName>}`]: BelongsToManyHasAssociationMixin<T, T[K]>;
+} & {
+  //检查是否关联（多个&关系）
+  [Key in `has${Capitalize<PluralAssociationName>}`]: BelongsToManyHasAssociationsMixin<T, T[K]>;
+} & {
+  //统计关联模型数量
+  [Key in `counts${Capitalize<AssociationName>}`]: BelongsToManyGetAssociationsMixin<T>;
+};
+
+/**
+ * @private
+ * {@link InferAttributesLoose} 使用的内部类型，用于排除* 以下属性：
+ * - functions
+ * - 继承自 {@link Model}
+ * - 使用 {@link InferAttributesOptions} 的 omit 选项手动排除
+ */
+type InternalInferAttributeKeysFromFieldsLoose<M extends Model, Key extends keyof M, Options extends InferAttributesOptions<keyof M | never | ''>> =
+  // fields inherited from Model are all excluded
+  Key extends keyof Model
+    ? never
+    : // functions are always excluded
+    M[Key] extends AnyFunction
+    ? never
+    : // : // fields branded with NonAttribute are excluded
+    //   IsBranded<M[Key], typeof NonAttributeBrand> extends true
+    //   ? never
+    // check 'omit' option is provided & exclude those listed in it
+    Options['omit'] extends string
+    ? Key extends Options['omit']
+      ? never
+      : Key
+    : Key;
+/**
+ * 用于提取给定模型类属性的实用类型(宽松的不会排除{@link NonAttribute}标记的属性)。
+ *
+ * 它返回模型中定义的所有实例属性，但不包括：
+ * - 从模型继承的属性（中间继承有效），
+ * - 类型为函数的属性，
+ * - 使用第二个参数手动排除的属性。
+ *
+ *  使用 {@link NonAttribute} 会正常再里边没有排除
+ * 它无法检测某个属性是否是 getter，你应该使用 `Excluded` 参数将 getter 和 setter 从属性列表中排除。
+ *
+ * @example
+ * ```javascript
+ * // listed attributes will be 'id' & 'firstName'.
+ * class User extends Model<InferAttributes<User>> {
+ *   id: number;
+ *   firstName: string;
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // listed attributes will be 'id' & 'firstName'.
+ * // we're excluding the `name` getter & `projects` attribute using the `omit` option.
+ * class User extends Model<InferAttributes<User, { omit: 'name' | 'projects' }>> {
+ *   id: number;
+ *   firstName: string;
+ *
+ *   // this is an association, it should not be listed in attributes
+ *   projects?: Project[];
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // listed attributes will be 'id' & 'firstName'.
+ * // we're excluding the `name` getter & `test` attribute using the `NonAttribute` branded type.
+ * class User extends Model<InferAttributes<User>> {
+ *   id: number;
+ *   firstName: string;
+ *
+ *   // this is a getter function, not an attribute. It should not be listed in attributes.
+ *   get name(): string { return this.firstName; }
+ * }
+ * ```
+ */
+export type InferAttributesLoose<M extends Model, Options extends InferAttributesOptions<keyof M | never | ''> = { omit: never }> = {
+  [Key in keyof M as InternalInferAttributeKeysFromFieldsLoose<M, Key, Options>]: M[Key];
+};

package/template/meadmin/src/types/fileManage.ts

@@ -0,0 +1,48 @@
+import { UploadStreamFileInfo } from '@midwayjs/busboy';
+import { ReadStream } from 'node:fs';
+
+export type UploadParam = {
+  //文件名
+  name: string;
+  //md5值
+  md5: string;
+  //分片上传:0=否;1=是
+  chunk: string;
+  //当前分片md5值
+  chunkMd5?: string;
+  //当前分片起止位置(从0开始)/
+  start?: string;
+  //是否结束(需确保最后一个分片上传时其他分片请求已完成):0=否;1=是
+  over?: string;
+};
+export type UploadResult = {
+  storage: string;
+  md5: string;
+  name: string;
+  mimeType: string;
+  size: number;
+  path: string;
+};
+export interface UpStorageInterface {
+  model: string; //用户的model一般为
+  /**
+   * 上次文件函数，需支持断点续传
+   * @param file 文件
+   * @param params 参数
+   * @returns Promise<null | UploadResult> | null | UploadResult ,null 断点未上传完成，UploadResult文件上传完毕|
+   */
+  upload: (file: UploadStreamFileInfo, params: UploadParam) => Promise<null | UploadResult> | null | UploadResult;
+  /**
+   * 获取文件真实访问路径
+   * @param path 相对路径
+   * @returns Promise<string> | string 完整路径
+   */
+  getFilePath: (path: string) => Promise<string> | string;
+  /**
+   * 获取文件读取流
+   * @param path 相对路径
+   * @returns Promise<ReadStream> | ReadStream 读取流
+   */
+  getFileReadSteam: (path: string) => Promise<ReadStream> | ReadStream;
+}
+export type UpStorageFunction = (model: string) => UpStorageInterface;

package/template/meadmin/src/types/koa.interface.ts

@@ -0,0 +1,12 @@
+import type { SystemAdmin } from '@/entities/systemAdmin.entity.ts';
+import type { User } from '@/entities/user.entity.ts';
+// 下面这段只 @midwayjs/koa 的 Context 做扩展
+import '@midwayjs/koa';
+declare module '@midwayjs/koa' {
+  export interface Context {
+    //管理员信息，只有没跳过登录校验的admin接口才能拿到
+    adminInfo?: SystemAdmin;
+    //用户信息，只有传token才能拿到
+    userInfo?: User;
+  }
+}

package/template/meadmin/src/types/uploadOptions.ts

@@ -0,0 +1,7 @@
+import '@midwayjs/busboy';
+
+declare module '@midwayjs/busboy' {
+  export interface UploadOptions {
+    upDir: string; //文件存储文件夹
+  }
+}

package/template/meadmin/test/controller/api.test.ts

@@ -0,0 +1,17 @@
+import { createHttpRequest } from '@midwayjs/mock';
+import { Application } from '@midwayjs/koa';
+import assert from 'assert';
+import { getApp } from '../setup.js';
+
+describe('test/controller/home.test.ts', () => {
+
+  it('should POST /api/get_user', async function (this: any) {
+    const app: Application = getApp();
+    // make request
+    const result = await createHttpRequest(app).get('/api/get_user').query({ uid: 123 });
+
+    // use expect by jest
+    assert(result.status ===200);
+    assert(result.body.message === 'OK');
+  });
+});

package/template/meadmin/test/controller/home.test.ts

@@ -0,0 +1,18 @@
+import { createHttpRequest } from '@midwayjs/mock';
+import { Application } from '@midwayjs/koa';
+import assert from 'assert';
+import { getApp } from '../setup.js';
+
+describe('test/controller/home.test.ts', () => {
+
+  it('should GET /', async () => {
+    const app: Application = getApp();
+    // make request
+    const result = await createHttpRequest(app).get('/');
+
+    // use expect by jest
+    assert(result.status === 200);
+    assert(result.text === 'Hello Midwayjs!');
+  });
+
+});

package/template/meadmin/test/setup.ts

@@ -0,0 +1,15 @@
+import { createApp, close } from '@midwayjs/mock';
+
+let app;
+export async function mochaGlobalSetup() {
+  // create app
+  app = await createApp();
+}
+
+export async function mochaGlobalTeardown() {
+  await close(app);
+};
+
+export function getApp() {
+  return app;
+}

package/template/meadmin/test/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends":"../tsconfig.json",
+  "compileOnSave": true,
+  "noEmit": true,
+  "compilerOptions": {
+    "rootDir": "../../",
+    "outDir": "dist",
+    "baseUrl": ".",
+    "preserveSymlinks": true
+  },
+  "include": [
+    "*.ts",
+    "**/*.ts",
+    "../src/**/*.ts",
+    "../types/**/*.d.ts",
+    "../index.d.ts",
+  ],
+  "exclude":[],
+}

package/template/meadmin/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "preserveSymlinks": false,
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "inlineSourceMap": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "stripInternal": true,
+    "skipLibCheck": true,
+    "pretty": true,
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "typeRoots": ["./typings", "./types", "./node_modules/@types"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "exclude": ["*.js", "*.ts", "dist", "node_modules", "test", "packages", "view"]
+}

package/template/meadmin/types/mwtsc.d.ts

@@ -0,0 +1,9 @@
+//对于第三方库的定义请放在types/中,并用.d.ts命名。正常的类型扩展或类型声明，请在src/types中创建并使用.ts声明。因为项目的"skipLibCheck": true,会调过.d.ts的类型检查
+declare module 'mwtsc' {
+  type Run = () => {
+    restart: () => void;
+    exit: () => void;
+    onExit: () => void;
+  };
+  export const run: Run;
+}

package/template/meadmin/view/admin/.prettierignore

@@ -0,0 +1,28 @@
+## OS
+.DS_Store
+.idea
+.editorconfig
+pnpm-lock.yaml
+.npmrc
+
+# Ignored suffix
+*.log
+*.md
+*.svg
+*.png
+*.ico
+*ignore
+LICENSE
+.env*
+## Local
+test
+.husky
+.github
+
+## Built-files
+.cache
+dist
+template
+
+## auto create files
+types/auto-imports.d.ts

package/template/meadmin/view/admin/.prettierrc.cjs

@@ -0,0 +1,4 @@
+// .prettierrc.js
+module.exports = {
+  ...require('../../.prettierrc.cjs'),
+};

package/template/meadmin/view/admin/cli/autoImport.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env ts-node
+import autoImport from '../plugins/autoImport.js';
+autoImport().buildStart();