jax-hono 1.0.0

package/plugins/mongoose/index.ts

@@ -0,0 +1,57 @@
+import mongoose from 'mongoose';
+import { definePlugin } from '../define';
+
+export type JaxPluginContext = {
+  mongoose?: typeof mongoose;
+};
+
+type MongoosePluginOptions = {
+  uri?: string;
+};
+
+async function connectMongoose(config: any, options: unknown) {
+  const uri = getMongooseUri(config, options);
+
+  if (!uri) {
+    throw new Error(
+      'Mongoose plugin requires options.uri, config.mongoose.uri, config.mongo.uri, or config.mongodb.'
+    );
+  }
+
+  // mongoose.set('strictQuery', true); // 严格查询模式
+
+  mongoose.set('toJSON', { virtuals: true, getters: true });
+  mongoose.set('debug', (collectionName, methodName, query, doc) => {
+    if (['request_log'].some((item) => collectionName.includes(item))) return;
+    console.log(`Mongoose: ${collectionName}.${methodName}`, JSON.stringify(query), doc);
+  });
+
+  await mongoose.connect(uri);
+
+  console.log('Mongoose connected');
+
+  return mongoose;
+}
+
+function getMongooseUri(config: any, options: unknown) {
+  const pluginOptions = isMongoosePluginOptions(options) ? options : {};
+
+  return pluginOptions.uri ?? config.mongoose?.uri ?? config.mongo?.uri ?? config.mongodb;
+}
+
+function isMongoosePluginOptions(options: unknown): options is MongoosePluginOptions {
+  return Boolean(options && typeof options === 'object' && !Array.isArray(options));
+}
+
+export default definePlugin({
+  async setup(ctx, options) {
+    ctx.plugin.mongoose = await connectMongoose(ctx.config, options);
+  },
+  async close() {
+    if (mongoose.connection.readyState !== 0) {
+      await mongoose.disconnect();
+    }
+  }
+});
+export * from './model';
+export * from './schema';

package/plugins/mongoose/model.ts

@@ -0,0 +1,281 @@
+import { basename, parse } from 'node:path';
+import mongoose, {
+  Schema,
+  model as mongooseModel,
+  type InferSchemaType,
+  type Model,
+  type SchemaOptions
+} from 'mongoose';
+import config from '@/jax/config';
+import { rankSetter } from './schema';
+import dayjs from 'dayjs';
+
+export { rankSetter };
+
+type PageOptions = {
+  page?: number | string;
+  pageSize?: number | string;
+  sort?: Record<string, unknown>;
+};
+
+export type ModelStatics = {
+  findPage(
+    filter?: Record<string, unknown>,
+    options?: PageOptions
+  ): Promise<{
+    total: number;
+    list: unknown[];
+    maxPage: number;
+    page: number;
+    pageSize: number;
+  }>;
+  tree(options?: {
+    filter?: Record<string, unknown>;
+    sort?: Record<string, unknown>;
+  }): Promise<unknown[]>;
+  flatTree(options?: {
+    filter?: Record<string, unknown>;
+    sort?: Record<string, unknown>;
+  }): Promise<unknown[]>;
+};
+
+export function createLooseModel(filePathOrName: string, collection?: string) {
+  const name = getModelName(filePathOrName);
+  const schema = new Schema({}, { strict: false });
+
+  applyDefaultSchemaOptions(schema);
+  installCommonFields(schema);
+  installModelStatics(schema);
+
+  return (
+    mongoose.models[name] ?? mongooseModel(name, schema, collection ?? getCollectionName(name))
+  );
+}
+
+export function createSchemaModel<TSchema extends Schema>(
+  filePathOrName: string,
+  schema: TSchema,
+  collection?: string
+): Model<InferSchemaType<TSchema>> & ModelStatics {
+  const name = getModelName(filePathOrName);
+
+  applyDefaultSchemaOptions(schema);
+  installCommonFields(schema);
+  installModelStatics(schema);
+
+  return (mongoose.models[name] ??
+    mongooseModel<InferSchemaType<TSchema>>(
+      name,
+      schema as any,
+      collection ?? getCollectionName(name)
+    )) as Model<InferSchemaType<TSchema>> & ModelStatics;
+}
+
+export const createModel = createSchemaModel;
+
+export function getModelName(filePathOrName: string) {
+  const baseName =
+    filePathOrName.includes('/') || filePathOrName.includes('\\')
+      ? parse(basename(filePathOrName)).name.replace(/\.model$/, '')
+      : filePathOrName;
+
+  return toPascalCase(baseName);
+}
+
+export function getCollectionName(modelName: string) {
+  const prefix = (config as any).mongoose?.prefix ?? (config as any).mongo?.prefix ?? '';
+  const name = toSnakeCase(modelName);
+
+  return prefix ? `${prefix}_${name}` : name;
+}
+
+export function schemaOptions(): SchemaOptions {
+  return {
+    timestamps: true,
+    versionKey: false,
+    toJSON: {
+      virtuals: true,
+      getters: true,
+      transform(_doc: unknown, ret: any) {
+        // if (ret._id && !ret.id) {
+        //   ret.id = ret._id.toString();
+        // }
+
+        if (ret.createdAt) {
+          ret.createdAt = dayjs(ret.createdAt).format('YYYY-MM-DD HH:mm:ss');
+        }
+
+        if (ret.updatedAt) {
+          ret.updatedAt = dayjs(ret.updatedAt).format('YYYY-MM-DD HH:mm:ss');
+        }
+
+        delete ret.__v;
+        delete ret._id;
+
+        return ret;
+      }
+    },
+    toObject: {
+      virtuals: true,
+      getters: true
+    }
+  };
+}
+
+export function applyDefaultSchemaOptions(schema: Schema) {
+  const defaults = schemaOptions();
+
+  if (schema.options.timestamps === undefined) {
+    schema.set('timestamps', defaults.timestamps);
+  }
+
+  if (schema.options.versionKey === undefined || schema.options.versionKey === '__v') {
+    schema.set('versionKey', defaults.versionKey);
+  }
+
+  const toJSON = {
+    ...defaults.toJSON,
+    ...(schema.options.toJSON ?? {})
+  } as any;
+
+  schema.set('toJSON', toJSON);
+  schema.set('toObject', {
+    ...defaults.toObject,
+    ...(schema.options.toObject ?? {})
+  } as any);
+}
+
+export function installRankHooks(schema: Schema) {
+  schema.pre(['updateOne', 'findOneAndUpdate', 'updateMany'], function () {
+    normalizeRank(this.getUpdate());
+  });
+
+  schema.pre('save', function () {
+    normalizeRank(this);
+  });
+}
+
+export function installAutoNo(schema: Schema, field: string, start = 0) {
+  schema.pre('save', async function () {
+    if (!this.isNew || this.get(field)) {
+      return;
+    }
+
+    const model = this.constructor as any;
+    const doc = await model.findOne({}).sort({ [field]: -1 });
+
+    this.set(field, (doc?.[field] ?? start) + 1);
+  });
+}
+
+export function installModelStatics(schema: Schema) {
+  schema.static('findPage', async function findPage(filter = {}, options: PageOptions = {}) {
+    const page = Number(options.page || 1);
+    const pageSize = Number(options.pageSize || 20);
+    const sort = (options.sort ?? { _id: -1 }) as any;
+    const total = await this.countDocuments(filter);
+    let query = this.find(filter).sort(sort);
+
+    if (pageSize !== -1) {
+      query = query.skip((page - 1) * pageSize).limit(pageSize);
+    }
+
+    const list = await query;
+
+    return {
+      total,
+      list,
+      maxPage: pageSize === -1 ? 1 : Math.ceil(total / pageSize),
+      page,
+      pageSize
+    };
+  });
+
+  schema.static('tree', async function tree(options: any = {}) {
+    const docs = await this.find(options.filter ?? {})
+      .sort(options.sort ?? {})
+      .lean({ virtuals: true });
+    const byId = new Map<string, any>();
+    const tree: any[] = [];
+
+    for (const doc of docs) {
+      const id = String(doc._id ?? doc.id);
+      byId.set(id, { ...doc, id, children: [] });
+    }
+
+    for (const item of byId.values()) {
+      const parentId = item.parentId ? String(item.parentId) : '';
+      const parent = parentId ? byId.get(parentId) : undefined;
+
+      if (parent) {
+        parent.children.push(item);
+      } else {
+        tree.push(item);
+      }
+    }
+
+    return tree;
+  });
+
+  schema.static('flatTree', async function flatTree(this: any, options: any = {}) {
+    const tree = await this.tree(options);
+    const list: any[] = [];
+
+    walkTree(tree, 1, list);
+
+    return list;
+  });
+}
+
+export function installCommonFields(schema: Schema) {
+  const fields: Record<string, unknown> = {};
+
+  if (!schema.path('isDelete')) {
+    fields.isDelete = { type: Boolean, default: false };
+  }
+
+  if (!schema.path('isOpen')) {
+    fields.isOpen = { type: Boolean, default: false };
+  }
+
+  if (Object.keys(fields).length > 0) {
+    schema.add(fields as any);
+  }
+}
+
+export function toSnakeCase(value: string) {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[-\s]+/g, '_')
+    .toLowerCase();
+}
+
+function toPascalCase(value: string) {
+  const camel = value.replace(/[-_\s]+([a-zA-Z0-9])/g, (_match, char: string) =>
+    char.toUpperCase()
+  );
+
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+function walkTree(items: any[], depth: number, list: any[]) {
+  for (const item of items) {
+    const { children = [], ...data } = item;
+
+    list.push({ ...data, children, index: depth });
+    walkTree(children, depth + 1, list);
+  }
+}
+
+function normalizeRank(data: any) {
+  if (!data) {
+    return;
+  }
+
+  const target = data.$set ?? data;
+
+  if (target.rank !== undefined) {
+    target.rank = rankSetter(target.rank);
+    target.isTop = target.rank !== null;
+  }
+}

package/plugins/mongoose/schema.ts

@@ -0,0 +1,27 @@
+import { Schema, type SchemaDefinitionProperty } from 'mongoose';
+import dayjs from 'dayjs';
+
+export const date = (format = 'YYYY-MM-DD HH:mm:ss'): SchemaDefinitionProperty<Date> =>
+  ({
+    type: Date,
+    get: (value?: Date) => (value ? dayjs(value).format(format) : value)
+  }) as SchemaDefinitionProperty<Date>;
+
+export const dateWithDefault = (
+  defaultValue: DateConstructor | (() => Date | number | string),
+  format = 'YYYY-MM-DD HH:mm:ss'
+): SchemaDefinitionProperty<Date> =>
+  ({
+    type: Date,
+    get: (value?: Date) => (value ? dayjs(value).format(format) : value),
+    default: defaultValue
+  }) as SchemaDefinitionProperty<Date>;
+
+export function rankSetter(value: unknown) {
+  return value !== '' && value !== undefined && value !== null ? Number(value) : null;
+}
+
+export const rankedFields = {
+  rank: { type: Number, set: rankSetter },
+  isTop: { type: Boolean, default: false }
+};

package/plugins/session/index.ts

@@ -0,0 +1,20 @@
+import { useSession, useSessionStorage } from '@hono/session'
+import type { SessionEnv } from '@hono/session'
+import { Hono } from 'hono'
+import { definePlugin } from '../define'
+
+export default definePlugin({
+  setup(ctx) {
+    ctx.app.use(
+      useSession({
+        secret: ctx.config?.session?.secret || 'jax-session',
+        duration: {
+          // 会话的有效时间以秒为单位。超过该时间后，会话将失效，需要重新认证才能继续使用。
+          absolute: 60 * 60 * 24 * 7, // 7天
+          // 会话被视为活跃的时间长度，以秒为单位。在这一时间内，会话的最大年龄可以延长。
+          // inactivity: 60 * 5,
+        },
+      }),
+    )
+  },
+})

package/setup.ts

@@ -0,0 +1,11 @@
+import { generateConfig } from "./build/generate-config";
+import { generateRegistry } from "./build/generate-registry";
+
+export function setupJax() {
+  generateConfig();
+  generateRegistry();
+}
+
+if (import.meta.main) {
+  setupJax();
+}

package/types/config.ts

@@ -0,0 +1,13 @@
+export type JaxConfig = {
+  rootDir: string;
+  port: number;
+  env: string;
+
+  session?: {
+    secret?: string;
+    duration?: {
+      absolute: number;
+      inactivity?: number;
+    };
+  };
+};

package/types/context.ts

@@ -0,0 +1,10 @@
+import type { Models } from '../generated/models.generated';
+import type { Services } from '../generated/services.generated';
+
+export type JaxState = Record<string, unknown>;
+
+export type JaxContextVariables = {
+  model: Models;
+  service: Services;
+  state: JaxState;
+};

package/types/index.ts

@@ -0,0 +1,2 @@
+export * from './context';
+export type { JaxConfig } from './config';

package/utils/array.ts

@@ -0,0 +1,7 @@
+export function arrayFrom<T>(value: T | T[] | null | undefined): T[] {
+  if (value === null || value === undefined || value === '') {
+    return [];
+  }
+
+  return Array.isArray(value) ? value : [value];
+}

package/utils/crypto.ts

@@ -0,0 +1,9 @@
+import { createHash, randomBytes } from 'node:crypto';
+
+export function md5(value: string) {
+  return createHash('md5').update(value).digest('hex');
+}
+
+export function createToken(byteLength = 24) {
+  return randomBytes(byteLength).toString('hex');
+}

package/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './array';
+export * from './crypto';
+export * from './regexp';

package/utils/regexp.ts

@@ -0,0 +1,17 @@
+/**
+ * 转义正则表达式中的特殊字符，将字符串安全地用于动态构建正则表达式。
+ *
+ * 会将 `. * + ? ^ $ { } ( ) | [ ] \` 等特殊字符前加上反斜杠进行转义，
+ * 确保它们被当作字面字符匹配，而非正则语法符号。
+ *
+ * @param value - 需要转义的值，可以是任意类型，内部会通过 `String()` 转换为字符串
+ * @returns 转义后的字符串，可直接嵌入 `new RegExp()` 中安全使用
+ *
+ * @example
+ * escapeRegex('hello.world')   // => 'hello\\.world'
+ * escapeRegex('price$')         // => 'price\\$'
+ * escapeRegex(123)              // => '123'
+ */
+export function escapeRegex(value: unknown) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/utils/transform.ts

@@ -0,0 +1,3 @@
+import { pick, omit } from 'lodash-es';
+
+export { pick, omit };