jax-hono 1.0.20 → 1.0.21

package/core/app.ts

@@ -1,207 +1,207 @@
-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';
-
-type Models = GeneratedModels;
-type CreateServices = (ctx: AppContext) => Record<string, any>;
-type Services = ReturnType<CreateServices>;
-type Plugins = GeneratedPlugins;
-
-type MaybePromise<T> = T | Promise<T>;
-
-export type AppContext = {
-  app: Hono;
-  config: Config;
-  model: Models;
-  service: Services;
-  plugin: Plugins & Record<string, any>;
-};
-
-export type AppRuntimeDeps = {
-  models: Models;
-  createServices: CreateServices;
-};
-
-export type AppPluginObject = {
-  setup?: (ctx: AppContext, options?: unknown) => MaybePromise<void>;
-  ready?: (ctx: AppContext, options?: unknown) => MaybePromise<void>;
-  close?: (ctx: AppContext, options?: unknown) => MaybePromise<void>;
-};
-
-export type AppPlugin =
-  | ((ctx: AppContext, options?: unknown) => MaybePromise<void>)
-  | AppPluginObject;
-
-type ModuleItem<T> = {
-  name: string;
-  module?: T;
-  load?: () => Promise<{ default?: T } | T>;
-  enable?: (ctx: AppContext) => boolean;
-  options?: unknown;
-};
-
-type ActivePlugin = {
-  name: string;
-  plugin: AppPluginObject;
-  options?: unknown;
-};
-
-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 ctx: AppContext = {
-    app,
-    config,
-    model: deps.models,
-    service: undefined as unknown as Services,
-    plugin: {} as Plugins
-  };
-  const activePlugins: ActivePlugin[] = [];
-  let activeCrons: ReturnType<typeof startCronJobs> = [];
-
-  ctx.service = deps.createServices(ctx);
-  app.jax = ctx;
-
-  app.use('*', requestLog);
-
-  app.use('*', async (c, next) => {
-    const state = {};
-
-    c.state = state;
-    c.model = ctx.model;
-    c.service = ctx.service;
-
-    c.set('state', state);
-    c.set('model', ctx.model);
-    c.set('service', ctx.service);
-
-    await runWithJaxContext(c, next);
-  });
-
-  const ready = Promise.all(
-    (pluginModules as readonly ModuleItem<AppPlugin>[]).map((item) => setupPluginSafely(item, ctx))
-  ).then(async (plugins) => {
-    activePlugins.push(...plugins.filter((plugin): plugin is ActivePlugin => Boolean(plugin)));
-
-    printEnabledPlugins(activePlugins);
-
-    await Promise.all(activePlugins.map((plugin) => runPluginReadySafely(plugin, ctx)));
-
-    activeCrons = startCronJobs(cronModules, ctx);
-  });
-
-  app.ready = ready;
-  app.close = async () => {
-    await ready.catch(() => undefined);
-    stopCronJobs(activeCrons);
-    await closePluginsSafely(activePlugins, ctx);
-  };
-
-  return app;
-}
-
-async function setupPlugin(
-  item: ModuleItem<AppPlugin>,
-  ctx: AppContext
-): Promise<ActivePlugin | undefined> {
-  if (item.enable && !item.enable(ctx)) {
-    return;
-  }
-
-  const loadedPlugin = item.module ?? (await loadPlugin(item));
-  const plugin =
-    loadedPlugin && typeof loadedPlugin === 'object' && 'default' in loadedPlugin
-      ? loadedPlugin.default
-      : loadedPlugin;
-
-  if (typeof plugin === 'function') {
-    await plugin(ctx, item.options);
-    return;
-  }
-
-  if (isPluginObject(plugin)) {
-    await plugin.setup?.(ctx, item.options);
-    return {
-      name: item.name,
-      plugin,
-      options: item.options
-    };
-  }
-
-  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') {
-    return false;
-  }
-
-  return ['setup', 'ready', 'close'].some((key) => key in plugin);
-}
-
-async function loadPlugin(item: ModuleItem<AppPlugin>) {
-  if (!item.load) {
-    throw new TypeError(`Plugin ${item.name} must define module or load.`);
-  }
-
-  return item.load();
-}
-
-async function setupPluginSafely(item: ModuleItem<AppPlugin>, ctx: AppContext) {
-  try {
-    return await setupPlugin(item, ctx);
-  } catch (error) {
-    console.error(`Jax plugin setup failed [${item.name}]:`, error);
-    return undefined;
-  }
-}
-
-async function runPluginReadySafely(item: ActivePlugin, ctx: AppContext) {
-  if (!item.plugin.ready) {
-    return;
-  }
-
-  try {
-    await item.plugin.ready(ctx, item.options);
-  } catch (error) {
-    console.error(`Jax plugin ready failed [${item.name}]:`, error);
-  }
-}
-
-function printEnabledPlugins(plugins: ActivePlugin[]) {
-  if (plugins.length === 0) {
-    console.log('[plugins] enabled: none');
-    return;
-  }
-
-  console.log(`[plugins] enabled: ${plugins.map((plugin) => plugin.name).join(', ')}`);
-}
-
-async function closePluginsSafely(plugins: ActivePlugin[], ctx: AppContext) {
-  for (const item of [...plugins].reverse()) {
-    if (!item.plugin.close) {
-      continue;
-    }
-
-    try {
-      await item.plugin.close(ctx, item.options);
-    } catch (error) {
-      console.error(`Jax plugin close failed [${item.name}]:`, error);
-    }
-  }
-}
-
-export { createApi, createHono, registerCrudRoutes };
+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';
+
+type Models = GeneratedModels;
+type CreateServices = (ctx: AppContext) => Record<string, any>;
+type Services = ReturnType<CreateServices>;
+type Plugins = GeneratedPlugins;
+
+type MaybePromise<T> = T | Promise<T>;
+
+export type AppContext = {
+  app: Hono;
+  config: Config;
+  model: Models;
+  service: Services;
+  plugin: Plugins & Record<string, any>;
+};
+
+export type AppRuntimeDeps = {
+  models: Models;
+  createServices: CreateServices;
+};
+
+export type AppPluginObject = {
+  setup?: (ctx: AppContext, options?: unknown) => MaybePromise<void>;
+  ready?: (ctx: AppContext, options?: unknown) => MaybePromise<void>;
+  close?: (ctx: AppContext, options?: unknown) => MaybePromise<void>;
+};
+
+export type AppPlugin =
+  | ((ctx: AppContext, options?: unknown) => MaybePromise<void>)
+  | AppPluginObject;
+
+type ModuleItem<T> = {
+  name: string;
+  module?: T;
+  load?: () => Promise<{ default?: T } | T>;
+  enable?: (ctx: AppContext) => boolean;
+  options?: unknown;
+};
+
+type ActivePlugin = {
+  name: string;
+  plugin: AppPluginObject;
+  options?: unknown;
+};
+
+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 ctx: AppContext = {
+    app,
+    config,
+    model: deps.models,
+    service: undefined as unknown as Services,
+    plugin: {} as Plugins
+  };
+  const activePlugins: ActivePlugin[] = [];
+  let activeCrons: ReturnType<typeof startCronJobs> = [];
+
+  ctx.service = deps.createServices(ctx);
+  app.jax = ctx;
+
+  app.use('*', requestLog);
+
+  app.use('*', async (c, next) => {
+    const state = {};
+
+    c.state = state;
+    c.model = ctx.model;
+    c.service = ctx.service;
+
+    c.set('state', state);
+    c.set('model', ctx.model);
+    c.set('service', ctx.service);
+
+    await runWithJaxContext(c, next);
+  });
+
+  const ready = Promise.all(
+    (pluginModules as readonly ModuleItem<AppPlugin>[]).map((item) => setupPluginSafely(item, ctx))
+  ).then(async (plugins) => {
+    activePlugins.push(...plugins.filter((plugin): plugin is ActivePlugin => Boolean(plugin)));
+
+    printEnabledPlugins(activePlugins);
+
+    await Promise.all(activePlugins.map((plugin) => runPluginReadySafely(plugin, ctx)));
+
+    activeCrons = startCronJobs(cronModules, ctx);
+  });
+
+  app.ready = ready;
+  app.close = async () => {
+    await ready.catch(() => undefined);
+    stopCronJobs(activeCrons);
+    await closePluginsSafely(activePlugins, ctx);
+  };
+
+  return app;
+}
+
+async function setupPlugin(
+  item: ModuleItem<AppPlugin>,
+  ctx: AppContext
+): Promise<ActivePlugin | undefined> {
+  if (item.enable && !item.enable(ctx)) {
+    return;
+  }
+
+  const loadedPlugin = item.module ?? (await loadPlugin(item));
+  const plugin =
+    loadedPlugin && typeof loadedPlugin === 'object' && 'default' in loadedPlugin
+      ? loadedPlugin.default
+      : loadedPlugin;
+
+  if (typeof plugin === 'function') {
+    await plugin(ctx, item.options);
+    return;
+  }
+
+  if (isPluginObject(plugin)) {
+    await plugin.setup?.(ctx, item.options);
+    return {
+      name: item.name,
+      plugin,
+      options: item.options
+    };
+  }
+
+  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') {
+    return false;
+  }
+
+  return ['setup', 'ready', 'close'].some((key) => key in plugin);
+}
+
+async function loadPlugin(item: ModuleItem<AppPlugin>) {
+  if (!item.load) {
+    throw new TypeError(`Plugin ${item.name} must define module or load.`);
+  }
+
+  return item.load();
+}
+
+async function setupPluginSafely(item: ModuleItem<AppPlugin>, ctx: AppContext) {
+  try {
+    return await setupPlugin(item, ctx);
+  } catch (error) {
+    console.error(`Jax plugin setup failed [${item.name}]:`, error);
+    return undefined;
+  }
+}
+
+async function runPluginReadySafely(item: ActivePlugin, ctx: AppContext) {
+  if (!item.plugin.ready) {
+    return;
+  }
+
+  try {
+    await item.plugin.ready(ctx, item.options);
+  } catch (error) {
+    console.error(`Jax plugin ready failed [${item.name}]:`, error);
+  }
+}
+
+function printEnabledPlugins(plugins: ActivePlugin[]) {
+  if (plugins.length === 0) {
+    console.log('[plugins] enabled: none');
+    return;
+  }
+
+  console.log(`[plugins] enabled: ${plugins.map((plugin) => plugin.name).join(', ')}`);
+}
+
+async function closePluginsSafely(plugins: ActivePlugin[], ctx: AppContext) {
+  for (const item of [...plugins].reverse()) {
+    if (!item.plugin.close) {
+      continue;
+    }
+
+    try {
+      await item.plugin.close(ctx, item.options);
+    } catch (error) {
+      console.error(`Jax plugin close failed [${item.name}]:`, error);
+    }
+  }
+}
+
+export { createApi, createHono, registerCrudRoutes };

package/core/controller.ts

@@ -1,85 +1,85 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import type { Context } from 'hono';
-import type { GeneratedModels, GeneratedServices } from './generated';
-
-const controllerContextStorage = new AsyncLocalStorage<Context>();
-type ControllerConstructor<T extends Controller> = new (...args: any[]) => T;
-type ControllerExport<T extends Controller> = T | ControllerConstructor<T>;
-
-export function runWithJaxContext<T>(c: Context, callback: () => T) {
-  return controllerContextStorage.run(c, callback);
-}
-
-export function getJaxContext() {
-  const context = controllerContextStorage.getStore();
-
-  if (!context) {
-    throw new Error('Jax request context is not available.');
-  }
-
-  return context;
-}
-
-export function createController<T extends Controller>(controller: ControllerExport<T>) {
-  return typeof controller === 'function' ? new controller() : controller;
-}
-
-export abstract class Controller {
-  constructor() {
-    this.bindMethods();
-  }
-
-  protected get context() {
-    return getJaxContext();
-  }
-
-  protected get ctx() {
-    return this.context;
-  }
-
-  protected get state() {
-    return this.context.get('state');
-  }
-
-  protected get model(): GeneratedModels {
-    return this.context.get('model');
-  }
-
-  protected get service(): GeneratedServices {
-    return this.context.get('service');
-  }
-
-  protected get session() {
-    return this.context.get('session');
-  }
-
-  private bindMethods() {
-    let prototype = Object.getPrototypeOf(this);
-
-    while (prototype && prototype !== Controller.prototype) {
-      for (const name of Object.getOwnPropertyNames(prototype)) {
-        if (name === 'constructor') {
-          continue;
-        }
-
-        const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
-
-        if (typeof descriptor?.value !== 'function') {
-          continue;
-        }
-
-        if (Object.prototype.hasOwnProperty.call(this, name)) {
-          continue;
-        }
-
-        Object.defineProperty(this, name, {
-          configurable: true,
-          writable: true,
-          value: descriptor.value.bind(this),
-        });
-      }
-
-      prototype = Object.getPrototypeOf(prototype);
-    }
-  }
-}
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Context } from 'hono';
+import type { GeneratedModels, GeneratedServices } from './generated';
+
+const controllerContextStorage = new AsyncLocalStorage<Context>();
+type ControllerConstructor<T extends Controller> = new (...args: any[]) => T;
+type ControllerExport<T extends Controller> = T | ControllerConstructor<T>;
+
+export function runWithJaxContext<T>(c: Context, callback: () => T) {
+  return controllerContextStorage.run(c, callback);
+}
+
+export function getJaxContext() {
+  const context = controllerContextStorage.getStore();
+
+  if (!context) {
+    throw new Error('Jax request context is not available.');
+  }
+
+  return context;
+}
+
+export function createController<T extends Controller>(controller: ControllerExport<T>) {
+  return typeof controller === 'function' ? new controller() : controller;
+}
+
+export abstract class Controller {
+  constructor() {
+    this.bindMethods();
+  }
+
+  protected get context() {
+    return getJaxContext();
+  }
+
+  protected get ctx() {
+    return this.context;
+  }
+
+  protected get state() {
+    return this.context.get('state');
+  }
+
+  protected get model(): GeneratedModels {
+    return this.context.get('model');
+  }
+
+  protected get service(): GeneratedServices {
+    return this.context.get('service');
+  }
+
+  protected get session() {
+    return this.context.get('session');
+  }
+
+  private bindMethods() {
+    let prototype = Object.getPrototypeOf(this);
+
+    while (prototype && prototype !== Controller.prototype) {
+      for (const name of Object.getOwnPropertyNames(prototype)) {
+        if (name === 'constructor') {
+          continue;
+        }
+
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+
+        if (typeof descriptor?.value !== 'function') {
+          continue;
+        }
+
+        if (Object.prototype.hasOwnProperty.call(this, name)) {
+          continue;
+        }
+
+        Object.defineProperty(this, name, {
+          configurable: true,
+          writable: true,
+          value: descriptor.value.bind(this),
+        });
+      }
+
+      prototype = Object.getPrototypeOf(prototype);
+    }
+  }
+}