jax-hono 1.0.21 → 1.0.22

package/build/generate-registry.ts

@@ -33,6 +33,10 @@ type EnabledPlugin = {
   rootDir: string
 }
 
+type PluginFile = EnabledPlugin & {
+  filePath: string
+}
+
 const controllerGroups: ControllerGroup[] = [
   { name: 'api', dirs: ['api', 'controllers/api', 'controller/api', 'modules'], suffix: '.api' },
   { name: 'backend', dirs: ['backend', 'controllers/backend', 'controller/backend', 'modules'], suffix: '.backend' },
@@ -213,6 +217,10 @@ function getEnabledPluginFiles(suffix: string) {
   })
 }
 
+function isPluginFile(item: { filePath: string } | PluginFile): item is PluginFile {
+  return 'name' in item && 'rootDir' in item
+}
+
 function isFileInDir(filePath: string, dirName: string) {
   const rel = relative(join(srcDir, dirName), filePath)
 
@@ -510,7 +518,7 @@ function generateServicesRegistry() {
       .map((match) => match[1])
       .sort((left, right) => left.localeCompare(right))
     const defaultServiceClass = source.match(/\bexport\s+default\s+class(?:\s+([a-zA-Z_$][a-zA-Z0-9_$]*))?/)
-    const fallbackServicePath = 'name' in item
+    const fallbackServicePath = isPluginFile(item)
       ? toPluginModulePath(item.name, item.rootDir, filePath, ['.service'])
       : toModulePath('services', filePath)
     const defaultServiceName = defaultServiceClass
@@ -827,24 +835,56 @@ function serializePluginOptions(options: unknown) {
   return options === undefined ? '' : `, options: ${JSON.stringify(options)}`
 }
 
+function pluginExportsJaxPluginContext(rootDir: string) {
+  const entryFiles = ['index.ts', 'index.js', 'index.mjs', 'index.cjs']
+
+  for (const fileName of entryFiles) {
+    const filePath = join(rootDir, fileName)
+
+    if (!existsSync(filePath)) {
+      continue
+    }
+
+    const content = readFileSync(filePath, 'utf8')
+
+    if (/\bexport\s+(?:type\s+)?(?:interface|type)\s+JaxPluginContext\b/.test(content)) {
+      return true
+    }
+  }
+
+  return false
+}
+
 function generatePluginContextRegistry() {
   const enabledPlugins = getEnabledPluginConfigItems()
   const imports = enabledPlugins.map(([name, item]) => {
     return `import ${toLowerCamelIdentifier([name], 'Plugin')} from ${JSON.stringify(item.package)}`
   })
+  const pluginContexts = enabledPlugins
+    .filter(([, item]) => pluginExportsJaxPluginContext(resolvePluginPackageDir(item.package)))
+    .map(([name, item]) => ({
+      importName: toLowerCamelIdentifier([name], 'PluginContext'),
+      packageName: item.package,
+    }))
+  const contextImports = pluginContexts.map(({ importName, packageName }) => {
+    return `import type { JaxPluginContext as ${importName} } from ${JSON.stringify(packageName)}`
+  })
+  const pluginContextTypes = pluginContexts.map(({ importName }) => importName)
   const exportNames = enabledPlugins.map(([name]) => toLowerCamelIdentifier([name], 'Plugin'))
   const moduleEntries = enabledPlugins.map(
     ([name, item]) =>
       `  { name: ${JSON.stringify(name)}, module: ${toLowerCamelIdentifier([name], 'Plugin')}${serializePluginOptions(item.options)} },`,
   )
   const exportBlock = formatExportBlock(exportNames)
+  const pluginsType = ['Record<string, unknown>', ...pluginContextTypes].join(' & ')
 
   const content = createGeneratedContent([
     imports.join('\n'),
+    contextImports.join('\n'),
     exportBlock,
-    `export const plugins = {} as Record<string, unknown>
+    `export type Plugins = ${pluginsType}
 
-export type Plugins = typeof plugins
+export const plugins = {} as Plugins
 
 declare module 'jax-hono/core/generated' {
   interface JaxGenerated {

package/core/api-controller.ts

@@ -1,4 +1,9 @@
 import { Controller } from "./controller";
+import {
+  addDateFilter,
+  addDateRangeFilter,
+  buildMongooseAutoFilter,
+} from "../plugins/mongoose/filter";
 import { arrayFrom } from "../utils/array";
 import { escapeRegex } from "../utils/regexp";
 import type { Context } from "hono";
@@ -32,6 +37,11 @@ export abstract class ApiController extends Controller {
     return true;
   }
 
+  // 启用自动过滤器
+  protected get enableAutoFilter() {
+    return getLegacyIsAllSearch(this) ?? false;
+  }
+
   protected get formatConcurrency() {
     return 50;
   }
@@ -183,13 +193,37 @@ export abstract class ApiController extends Controller {
 
   protected async getFilter(extraFilter?: Record<string, any>) {
     const query = this.context.req.query();
-    const filter: Record<string, any> = { ...(extraFilter ?? {}) };
-    const searchKeys = arrayFrom<string>(
-      (this as any).searchKey ?? (this as any).searchKeys,
+    const filter: Record<string, any> = {};
+    const searchKeys = collectKeys(
+      (this as any).searchKey,
+      (this as any).searchKeys,
     );
-    const likeKeys = arrayFrom<string>(
-      (this as any).likeKey ?? (this as any).likeKeys,
+    const likeKeys = collectKeys(
+      (this as any).likeKey,
+      (this as any).likeKeys,
     );
+    const keywordKeys = collectKeys((this as any).keywordKeys);
+
+    if (this.enableAutoFilter) {
+      Object.assign(filter, buildMongooseAutoFilter(this.Model, query));
+    } else {
+      addDateFilter(filter, query, "createdAt", "createdAt");
+      addDateRangeFilter(
+        filter,
+        query,
+        "createdAt",
+        "createdAtStart",
+        "createdAtEnd",
+      );
+    }
+
+    if (keywordKeys.length && query.keyword) {
+      const reg = new RegExp(escapeRegex(query.keyword), "i");
+      filter.$or = [
+        ...(Array.isArray(filter.$or) ? filter.$or : []),
+        ...keywordKeys.map((key) => ({ [key]: reg })),
+      ];
+    }
 
     for (const key of searchKeys) {
       if (query[key] !== undefined && query[key] !== "") {
@@ -215,6 +249,10 @@ export abstract class ApiController extends Controller {
       Object.assign(filter, (this as any).filter);
     }
 
+    if (extraFilter) {
+      Object.assign(filter, extraFilter);
+    }
+
     return filter;
   }
 
@@ -288,3 +326,38 @@ function getCustomMethod(target: object, name: string, baseMethod: Function) {
 
   return undefined;
 }
+
+function getLegacyIsAllSearch(target: object) {
+  if (Object.prototype.hasOwnProperty.call(target, "isAllSearch")) {
+    return Boolean((target as any).isAllSearch);
+  }
+
+  let prototype = Object.getPrototypeOf(target);
+
+  while (prototype && prototype !== ApiController.prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(
+      prototype,
+      "isAllSearch",
+    );
+
+    if (descriptor?.get) {
+      return Boolean(descriptor.get.call(target));
+    }
+
+    if (
+      "value" in (descriptor ?? {}) &&
+      descriptor?.value !== undefined &&
+      typeof descriptor.value !== "function"
+    ) {
+      return Boolean(descriptor.value);
+    }
+
+    prototype = Object.getPrototypeOf(prototype);
+  }
+
+  return undefined;
+}
+
+function collectKeys(...values: unknown[]) {
+  return values.flatMap((value) => arrayFrom<string>(value as any));
+}

package/core/app.ts

@@ -1,13 +1,18 @@
-import { createHono, createApi } from './hono';
-import { registerCrudRoutes } from '../helpers/crud';
-import config from '../config';
-import type { Config } from '../config';
-import { requireGeneratedModule, type GeneratedModels, type GeneratedPlugins } from './generated';
-import { runWithJaxContext } from './controller';
-import { startCronJobs, stopCronJobs } from './cron';
-import { requestLog } from '../middleware/request-log';
-import type { Hono } from 'hono';
-import type { JaxHono } from './hono';
+import { createHono, createApi } from "./hono";
+import { registerCrudRoutes } from "../helpers/crud";
+import config from "../config";
+import type { Config } from "../config";
+import {
+  requireGeneratedModule,
+  type GeneratedModels,
+  type GeneratedPlugins,
+} from "./generated";
+import { runWithJaxContext } from "./controller";
+import { startCronJobs, stopCronJobs } from "./cron";
+import { logger } from "../middleware/logger";
+import { requestLog } from "../middleware/request-log";
+import type { Hono } from "hono";
+import type { JaxHono } from "./hono";
 
 type Models = GeneratedModels;
 type CreateServices = (ctx: AppContext) => Record<string, any>;
@@ -55,19 +60,19 @@ type ActivePlugin = {
 
 export function createApp(deps: AppRuntimeDeps): JaxHono {
   const app = createHono();
-  const { pluginModules } = requireGeneratedModule<{ pluginModules: readonly ModuleItem<AppPlugin>[] }>(
-    'plugins.generated.ts'
-  );
-  const { cronModules } = requireGeneratedModule<{ cronModules: Parameters<typeof startCronJobs>[0] }>(
-    'crons.generated.ts'
-  );
+  const { pluginModules } = requireGeneratedModule<{
+    pluginModules: readonly ModuleItem<AppPlugin>[];
+  }>("plugins.generated.ts");
+  const { cronModules } = requireGeneratedModule<{
+    cronModules: Parameters<typeof startCronJobs>[0];
+  }>("crons.generated.ts");
 
   const ctx: AppContext = {
     app,
     config,
     model: deps.models,
     service: undefined as unknown as Services,
-    plugin: {} as Plugins
+    plugin: {} as Plugins,
   };
   const activePlugins: ActivePlugin[] = [];
   let activeCrons: ReturnType<typeof startCronJobs> = [];
@@ -75,30 +80,38 @@ export function createApp(deps: AppRuntimeDeps): JaxHono {
   ctx.service = deps.createServices(ctx);
   app.jax = ctx;
 
-  app.use('*', requestLog);
-
-  app.use('*', async (c, next) => {
+  app.use("*", async (c, next) => {
     const state = {};
 
     c.state = state;
     c.model = ctx.model;
     c.service = ctx.service;
+    c.plugin = ctx.plugin;
 
-    c.set('state', state);
-    c.set('model', ctx.model);
-    c.set('service', ctx.service);
+    c.set("state", state);
+    c.set("model", ctx.model);
+    c.set("service", ctx.service);
+    c.set("plugin", ctx.plugin);
 
     await runWithJaxContext(c, next);
   });
 
+  app.use("*", logger);
+
   const ready = Promise.all(
-    (pluginModules as readonly ModuleItem<AppPlugin>[]).map((item) => setupPluginSafely(item, ctx))
+    (pluginModules as readonly ModuleItem<AppPlugin>[]).map((item) =>
+      setupPluginSafely(item, ctx),
+    ),
   ).then(async (plugins) => {
-    activePlugins.push(...plugins.filter((plugin): plugin is ActivePlugin => Boolean(plugin)));
+    activePlugins.push(
+      ...plugins.filter((plugin): plugin is ActivePlugin => Boolean(plugin)),
+    );
 
     printEnabledPlugins(activePlugins);
 
-    await Promise.all(activePlugins.map((plugin) => runPluginReadySafely(plugin, ctx)));
+    await Promise.all(
+      activePlugins.map((plugin) => runPluginReadySafely(plugin, ctx)),
+    );
 
     activeCrons = startCronJobs(cronModules, ctx);
   });
@@ -115,7 +128,7 @@ export function createApp(deps: AppRuntimeDeps): JaxHono {
 
 async function setupPlugin(
   item: ModuleItem<AppPlugin>,
-  ctx: AppContext
+  ctx: AppContext,
 ): Promise<ActivePlugin | undefined> {
   if (item.enable && !item.enable(ctx)) {
     return;
@@ -123,11 +136,13 @@ async function setupPlugin(
 
   const loadedPlugin = item.module ?? (await loadPlugin(item));
   const plugin =
-    loadedPlugin && typeof loadedPlugin === 'object' && 'default' in loadedPlugin
+    loadedPlugin &&
+    typeof loadedPlugin === "object" &&
+    "default" in loadedPlugin
       ? loadedPlugin.default
       : loadedPlugin;
 
-  if (typeof plugin === 'function') {
+  if (typeof plugin === "function") {
     await plugin(ctx, item.options);
     return;
   }
@@ -137,19 +152,21 @@ async function setupPlugin(
     return {
       name: item.name,
       plugin,
-      options: item.options
+      options: item.options,
     };
   }
 
-  throw new TypeError(`Plugin ${item.name} must export a function or lifecycle object.`);
+  throw new TypeError(
+    `Plugin ${item.name} must export a function or lifecycle object.`,
+  );
 }
 
 function isPluginObject(plugin: unknown): plugin is AppPluginObject {
-  if (!plugin || typeof plugin !== 'object') {
+  if (!plugin || typeof plugin !== "object") {
     return false;
   }
 
-  return ['setup', 'ready', 'close'].some((key) => key in plugin);
+  return ["setup", "ready", "close"].some((key) => key in plugin);
 }
 
 async function loadPlugin(item: ModuleItem<AppPlugin>) {
@@ -183,11 +200,13 @@ async function runPluginReadySafely(item: ActivePlugin, ctx: AppContext) {
 
 function printEnabledPlugins(plugins: ActivePlugin[]) {
   if (plugins.length === 0) {
-    console.log('[plugins] enabled: none');
+    console.log("[plugins] enabled: none");
     return;
   }
 
-  console.log(`[plugins] enabled: ${plugins.map((plugin) => plugin.name).join(', ')}`);
+  console.log(
+    `[plugins] enabled: ${plugins.map((plugin) => plugin.name).join(", ")}`,
+  );
 }
 
 async function closePluginsSafely(plugins: ActivePlugin[], ctx: AppContext) {

package/core/controller.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { Context } from 'hono';
-import type { GeneratedModels, GeneratedServices } from './generated';
+import type { GeneratedModels, GeneratedPlugins, GeneratedServices } from './generated';
 
 const controllerContextStorage = new AsyncLocalStorage<Context>();
 type ControllerConstructor<T extends Controller> = new (...args: any[]) => T;
@@ -49,6 +49,10 @@ export abstract class Controller {
     return this.context.get('service');
   }
 
+  protected get plugin(): GeneratedPlugins {
+    return this.context.get('plugin');
+  }
+
   protected get session() {
     return this.context.get('session');
   }

package/core/hono.ts

@@ -1,7 +1,7 @@
 import { Hono } from 'hono';
 import { apiResponse } from '../middleware/api-response';
 import { registerCrudRoutes, type JaxCrudController } from '../helpers/crud';
-import type { GeneratedModels, GeneratedServices } from './generated';
+import type { GeneratedModels, GeneratedPlugins, GeneratedServices } from './generated';
 import type { JaxState } from '../types/context';
 
 declare module 'hono' {
@@ -9,11 +9,13 @@ declare module 'hono' {
     state: JaxState;
     model: GeneratedModels;
     service: GeneratedServices;
+    plugin: GeneratedPlugins;
   }
 
   interface ContextVariableMap {
     model: GeneratedModels;
     service: GeneratedServices;
+    plugin: GeneratedPlugins;
     state: JaxState;
   }
 }

package/middleware/logger.ts

@@ -0,0 +1,3 @@
+import { logger as honoLogger } from "hono/logger";
+
+export const logger = honoLogger();

package/middleware/request-log.ts

@@ -1,3 +1,114 @@
-import { logger } from 'hono/logger';
+import type { Context, MiddlewareHandler } from 'hono';
 
-export const requestLog = logger();
+type ContextWithRequestLog = Context & {
+  error?: unknown;
+  model?: {
+    RequestLog?: {
+      create(data: Record<string, unknown>): unknown | Promise<unknown>;
+    };
+  };
+  state?: unknown;
+};
+
+export const requestLog: MiddlewareHandler = async (c, next) => {
+  const start = Date.now();
+  const body = getRequestBody(c);
+  let thrownError: unknown;
+
+  try {
+    await next();
+  } catch (error) {
+    thrownError = error;
+    throw error;
+  } finally {
+    await createRequestLog(c as ContextWithRequestLog, start, body, thrownError);
+  }
+};
+
+async function createRequestLog(
+  c: ContextWithRequestLog,
+  start: number,
+  body: Promise<unknown>,
+  thrownError?: unknown
+) {
+  const RequestLog = c.model?.RequestLog;
+
+  if (!RequestLog) {
+    return;
+  }
+
+  try {
+    const data: Record<string, unknown> = {
+      ip: c.req.header('x-real-ip'),
+      url: c.req.url,
+      method: c.req.method,
+      body: await body,
+      query: c.req.query(),
+      headers: c.req.header(),
+      responseTime: Date.now() - start,
+      status: c.res.status,
+      state: c.state
+    };
+    const error = thrownError ?? c.error;
+
+    if (error) {
+      data.error = error instanceof Error
+        ? {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            cause: error.cause,
+            keys: Object.getOwnPropertyNames(error)
+          }
+        : {
+            message: String(error),
+            keys: []
+          };
+    }
+
+    if (c.res.status !== 200 && c.res.status !== 304) {
+      data.response = await c.res.clone().text().catch(() => undefined);
+    } else {
+      const response = await c.res.clone().json().catch(() => undefined);
+
+      if (response && typeof response === 'object' && 'code' in response) {
+        data.apiCode = response.code;
+        if (response.code !== 0) data.response = JSON.stringify(response);
+      }
+    }
+
+    await RequestLog.create(data);
+  } catch (error) {
+    console.error('Request log create failed:', error);
+  }
+}
+
+async function getRequestBody(c: Context) {
+  if (!hasRequestBody(c.req.method)) {
+    return undefined;
+  }
+
+  const contentType = c.req.header('content-type') ?? '';
+  const request = c.req.raw.clone();
+
+  try {
+    if (contentType.includes('application/json')) {
+      return await request.json();
+    }
+
+    if (
+      contentType.includes('application/x-www-form-urlencoded') ||
+      contentType.includes('multipart/form-data')
+    ) {
+      return Object.fromEntries(await request.formData());
+    }
+
+    return await request.text();
+  } catch {
+    return undefined;
+  }
+}
+
+function hasRequestBody(method: string) {
+  return !['GET', 'HEAD'].includes(method.toUpperCase());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jax-hono",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "Lightweight framework layer on top of Hono, built for Bun",
   "type": "module",
   "main": "./index.ts",

package/plugins/mongoose/filter.ts

@@ -0,0 +1,132 @@
+import { escapeRegex } from "../../utils/regexp";
+
+export type MongooseQueryValue = string | number | boolean;
+export type MongooseQuery = Record<string, string>;
+
+export type MongooseAutoFilterOptions = {
+  excludeKeys?: string[];
+};
+
+const defaultExcludeKeys = ["id", "_v", "__v"];
+
+export function buildMongooseAutoFilter(
+  modelOrSchema: any,
+  query: MongooseQuery,
+  options: MongooseAutoFilterOptions = {},
+) {
+  const filter: Record<string, any> = {};
+  const schema = modelOrSchema?.schema ?? modelOrSchema;
+  const tree = schema?.tree ?? schema?.paths ?? {};
+  const excludeKeys = new Set([
+    ...defaultExcludeKeys,
+    ...(options.excludeKeys ?? []),
+  ]);
+
+  for (const key in tree) {
+    if (excludeKeys.has(key)) {
+      continue;
+    }
+
+    const schemaType = getSchemaPath(schema, key);
+
+    if (schemaType?.instance === "Date") {
+      addDateFilter(filter, query, key);
+      addDateRangeFilter(filter, query, key, `${key}Start`, `${key}End`);
+    }
+  }
+
+  for (const [key, rawValue] of Object.entries(query)) {
+    if (rawValue === undefined || rawValue === "") {
+      continue;
+    }
+
+    const schemaType = getSchemaPath(schema, key);
+
+    if (!schemaType || schemaType.instance === "Date") {
+      continue;
+    }
+
+    filter[key] = normalizeSchemaFilterValue(rawValue, schemaType.instance);
+  }
+
+  return filter;
+}
+
+export function addDateFilter(
+  filter: Record<string, any>,
+  query: MongooseQuery,
+  targetField: string,
+  queryKey = targetField,
+) {
+  if (!query[queryKey]) {
+    return;
+  }
+
+  filter[targetField] = {
+    $gte: new Date(`${query[queryKey]} 00:00:00`),
+    $lte: new Date(`${query[queryKey]} 23:59:59`),
+  };
+}
+
+export function addDateRangeFilter(
+  filter: Record<string, any>,
+  query: MongooseQuery,
+  targetField = "createdAt",
+  startDateField = `${targetField}Start`,
+  endDateField = `${targetField}End`,
+) {
+  if (query[startDateField]) {
+    filter[targetField] = {
+      $gte: new Date(processDateRange(query[startDateField], true)),
+    };
+  }
+
+  if (query[endDateField]) {
+    filter[targetField] = {
+      ...filter[targetField],
+      $lte: new Date(processDateRange(query[endDateField], false)),
+    };
+  }
+}
+
+function getSchemaPath(schema: any, key: string) {
+  return typeof schema?.path === "function"
+    ? schema.path(key)
+    : schema?.paths?.[key];
+}
+
+function normalizeSchemaFilterValue(
+  value: MongooseQueryValue,
+  schemaInstance?: string,
+) {
+  switch (schemaInstance) {
+    case "String":
+      return new RegExp(escapeRegex(value), "i");
+    case "ObjectId":
+      return value;
+    case "Number":
+      return Number(value);
+    case "Boolean":
+      return normalizeBoolean(value);
+    default:
+      return value;
+  }
+}
+
+function normalizeBoolean(value: MongooseQueryValue) {
+  if (typeof value === "string") {
+    return value === "true";
+  }
+
+  if (typeof value === "number") {
+    return value === 1;
+  }
+
+  return value;
+}
+
+function processDateRange(value: string, isStart: boolean) {
+  return value.length === 10
+    ? `${value} ${isStart ? "00:00:00" : "23:59:59"}`
+    : value;
+}

package/plugins/mongoose/index.ts

@@ -55,3 +55,4 @@ export default definePlugin({
 });
 export * from './model';
 export * from './schema';
+export * from './filter';

package/types/context.ts

@@ -1,9 +1,10 @@
-import type { GeneratedModels, GeneratedServices } from '../core/generated';
+import type { GeneratedModels, GeneratedPlugins, GeneratedServices } from '../core/generated';
 
 export type JaxState = Record<string, unknown>;
 
 export type JaxContextVariables = {
   model: GeneratedModels;
   service: GeneratedServices;
+  plugin: GeneratedPlugins;
   state: JaxState;
 };