appos 0.3.1-0 → 0.3.3-0

package/dist/exports/api/event.mjs

@@ -1 +1,236 @@
-import{defineRedisClient as e}from"./redis.mjs";import{APPOS_DIR as t,EVENTS_DIR as n,FILE_EXT as r}from"./constants.mjs";import{z as i}from"zod";import{basename as a,join as o}from"node:path";import{glob as s}from"node:fs/promises";import{camelCase as c}from"es-toolkit";function l(t){let n=e({logger:t.logger,url:t.dbUrl}),r=null,i=new Map;return{async publish(e,t){await n.publish(e,JSON.stringify(t))},async subscribe(e,a){return r||(r=n.duplicate(),await r.connect()),i.has(e)||(i.set(e,new Set),await r.subscribe(e,n=>{let r=i.get(e);if(r){let i;try{i=JSON.parse(n)}catch(r){t.logger.error({err:r,channel:e,msg:n},`Failed to parse event message`);return}for(let n of r)try{n(i)}catch(n){t.logger.error({err:n,channel:e},`Event handler error`)}}})),i.get(e).add(a),()=>{let t=i.get(e);t&&t.delete(a)}},hasSubscribers(e){let t=i.get(e);return t!==void 0&&t.size>0},async close(){r?.isOpen&&await r.quit(),n.isOpen&&await n.quit()}}}function u(e){let t=null,n=null;return{inputSchema:e.input,get name(){return n},register(e,r){t=e,n=r},async emit(r){if(!t||!n)throw Error(`Event not registered. Ensure the worker is started before emitting events.`);let i=e.input.parse(r),a={container:t,input:i};await e.run(a),t.eventBus.publish(n,i).catch(e=>{t.logger.error({err:e,event:n},`Redis publish failed`)})},async subscribe(r){if(!t||!n)throw Error(`Event not registered. Ensure the worker is started before subscribing.`);return t.eventBus.subscribe(n,async i=>{let a=e.input.parse(i),o={container:t,input:a};try{await r(o)}catch(e){t.logger.error({err:e,event:n},`Event subscription handler error`)}})}}}const d=i.object({action:i.enum([`INSERT`,`UPDATE`,`DELETE`]),newData:i.record(i.string(),i.unknown()).nullable(),oldData:i.record(i.string(),i.unknown()).nullable(),organizationId:i.string().nullable(),tableName:i.string(),timestamp:i.string(),userId:i.string().nullable()}),f=u({input:d,async run(){}});function p(e){return c(a(e,`.ts`))}async function m(e){let{container:i}=e,a=e.eventsDir??o(process.cwd(),t,n);f.register(i,`dbChanges`);let c=await Array.fromAsync(s(`${a}/**/*.${r}`,{exclude:[`**/*.test.ts`,`**/*.spec.ts`,`**/*.test.js`,`**/*.spec.js`]}));for(let e of c){let t=await import(e);if(t.default&&typeof t.default==`object`&&`emit`in t.default&&`subscribe`in t.default){let n=p(e);t.default.register(i,n)}}}export{d as dbChangeInputSchema,f as dbChangesEvent,u as defineEvent,l as defineEventBus,m as loadEvents};
+import { defineRedisClient } from "./redis.mjs";
+import { APPOS_DIR, EVENTS_DIR, FILE_EXT } from "./constants.mjs";
+import { z } from "zod";
+import { basename, join } from "node:path";
+import { glob } from "node:fs/promises";
+import { camelCase } from "es-toolkit";
+
+//#region src/api/event.ts
+/**
+* Defines the event bus for pub/sub messaging.
+* Uses Redis for cross-server communication.
+*
+* Algorithm:
+* 1. Create lazy Redis publisher client
+* 2. Create lazy Redis subscriber client
+* 3. Manage subscriptions via callback registry
+* 4. Provide publish/subscribe/close methods
+*
+* @param opts - Event bus configuration
+* @returns Event bus instance
+*/
+function defineEventBus(opts) {
+	const publisherClient = defineRedisClient({
+		logger: opts.logger,
+		url: opts.dbUrl
+	});
+	let subscriberClient = null;
+	const subscribers = /* @__PURE__ */ new Map();
+	return {
+		async publish(channel, message) {
+			await publisherClient.publish(channel, JSON.stringify(message));
+		},
+		async subscribe(channel, callback) {
+			if (!subscriberClient) {
+				subscriberClient = publisherClient.duplicate();
+				await subscriberClient.connect();
+			}
+			if (!subscribers.has(channel)) {
+				subscribers.set(channel, /* @__PURE__ */ new Set());
+				await subscriberClient.subscribe(channel, (msg) => {
+					const callbacks = subscribers.get(channel);
+					if (callbacks) {
+						let parsed;
+						try {
+							parsed = JSON.parse(msg);
+						} catch (err) {
+							opts.logger.error({
+								err,
+								channel,
+								msg
+							}, "Failed to parse event message");
+							return;
+						}
+						for (const cb of callbacks) try {
+							cb(parsed);
+						} catch (err) {
+							opts.logger.error({
+								err,
+								channel
+							}, "Event handler error");
+						}
+					}
+				});
+			}
+			subscribers.get(channel).add(callback);
+			return () => {
+				const callbacks = subscribers.get(channel);
+				if (callbacks) callbacks.delete(callback);
+			};
+		},
+		hasSubscribers(channel) {
+			const callbacks = subscribers.get(channel);
+			return callbacks !== void 0 && callbacks.size > 0;
+		},
+		async close() {
+			if (subscriberClient?.isOpen) await subscriberClient.quit();
+			if (publisherClient.isOpen) await publisherClient.quit();
+		}
+	};
+}
+/**
+* Defines a type-safe event with in-memory and Redis pub/sub support.
+*
+* Algorithm:
+* 1. Define event with input schema and in-memory run handler
+* 2. On emit(): validate input, run in-memory handler, publish to Redis (fire-and-forget)
+* 3. .subscribe() creates Redis subscription for tRPC/SSE/WebSocket handlers
+*
+* @example
+* ```typescript
+* // api/events/order-status.ts
+* export default defineEvent({
+*   input: z.object({
+*     orderId: z.string(),
+*     status: z.enum(["pending", "shipped", "delivered"]),
+*   }),
+*   async run(ctx) {
+*     ctx.container.logger.info(`Order ${ctx.input.orderId} is ${ctx.input.status}`);
+*   },
+* });
+*
+* // Emit from anywhere
+* await orderStatus.emit({ orderId: "123", status: "shipped" });
+*
+* // Subscribe (e.g., in tRPC router)
+* const unsubscribe = await orderStatus.subscribe(async (ctx) => {
+*   // Push to client via SSE/WebSocket
+* });
+* // Cleanup when client disconnects
+* unsubscribe();
+* ```
+*/
+function defineEvent(options) {
+	let container = null;
+	let eventName = null;
+	return {
+		inputSchema: options.input,
+		get name() {
+			return eventName;
+		},
+		register(c, name) {
+			container = c;
+			eventName = name;
+		},
+		async emit(input) {
+			if (!container || !eventName) throw new Error("Event not registered. Ensure the worker is started before emitting events.");
+			const validated = options.input.parse(input);
+			const ctx = {
+				container,
+				input: validated
+			};
+			await options.run(ctx);
+			container.eventBus.publish(eventName, validated).catch((err) => {
+				container.logger.error({
+					err,
+					event: eventName
+				}, "Redis publish failed");
+			});
+		},
+		async subscribe(handler) {
+			if (!container || !eventName) throw new Error("Event not registered. Ensure the worker is started before subscribing.");
+			return container.eventBus.subscribe(eventName, async (message) => {
+				const validated = options.input.parse(message);
+				const ctx = {
+					container,
+					input: validated
+				};
+				try {
+					await handler(ctx);
+				} catch (err) {
+					container.logger.error({
+						err,
+						event: eventName
+					}, "Event subscription handler error");
+				}
+			});
+		}
+	};
+}
+/**
+* Input schema for dbChangesEvent.
+*/
+const dbChangeInputSchema = z.object({
+	action: z.enum([
+		"INSERT",
+		"UPDATE",
+		"DELETE"
+	]),
+	newData: z.record(z.string(), z.unknown()).nullable(),
+	oldData: z.record(z.string(), z.unknown()).nullable(),
+	organizationId: z.string().nullable(),
+	tableName: z.string(),
+	timestamp: z.string(),
+	userId: z.string().nullable()
+});
+/**
+* Built-in event for database changes.
+* Emitted by trackDbChanges workflow.
+*
+* @example
+* ```typescript
+* // Subscribe to DB changes (e.g., in tRPC subscription)
+* import { dbChangesEvent } from "appos/api";
+*
+* const unsubscribe = await dbChangesEvent.subscribe(async (ctx) => {
+*   wsServer.publish("db-changes", JSON.stringify(ctx.input));
+* });
+*
+* // Cleanup when done
+* unsubscribe();
+* ```
+*/
+const dbChangesEvent = defineEvent({
+	input: dbChangeInputSchema,
+	async run() {}
+});
+/**
+* Extracts event name from filepath as camelCase.
+*/
+function getEventName(filepath) {
+	return camelCase(basename(filepath, ".ts"));
+}
+/**
+* Auto-discovers and registers all events from the given directory.
+*
+* Algorithm:
+* 1. Register built-in dbChangesEvent
+* 2. Glob all .ts files in the directory (excluding test files)
+* 3. Import each module's default export
+* 4. If it's an Event (has emit + subscribe), call register(container, name)
+*
+* @param opts - Load events options
+*/
+async function loadEvents(opts) {
+	const { container } = opts;
+	const eventsDir = opts.eventsDir ?? join(process.cwd(), APPOS_DIR, EVENTS_DIR);
+	dbChangesEvent.register(container, "dbChanges");
+	const files = await Array.fromAsync(glob(`${eventsDir}/**/*.${FILE_EXT}`, { exclude: [
+		"**/*.test.ts",
+		"**/*.spec.ts",
+		"**/*.test.js",
+		"**/*.spec.js"
+	] }));
+	for (const file of files) {
+		const mod = await import(file);
+		if (mod.default && typeof mod.default === "object") {
+			if ("emit" in mod.default && "subscribe" in mod.default) {
+				const name = getEventName(file);
+				mod.default.register(container, name);
+			}
+		}
+	}
+}
+
+//#endregion
+export { dbChangeInputSchema, dbChangesEvent, defineEvent, defineEventBus, loadEvents };

package/dist/exports/api/i18n.mjs

@@ -1 +1,45 @@
-import{LOCALES_DIR as e,PUBLIC_DIR as t}from"./constants.mjs";import{join as n}from"node:path";import{lstatSync as r,readdirSync as i,watch as a}from"node:fs";import{createInstance as o}from"i18next";import s from"i18next-fs-backend";import{initReactI18next as c}from"react-i18next";const l={fallbackLng:`en`,supportedLngs:[`en`],defaultNS:`translation`,ns:[`translation`],interpolation:{escapeValue:!1},react:{useSuspense:!1}};async function u(l){let u=n(t,e),d=o();return process.env.NODE_ENV!==`production`&&!process.env.VITEST&&a(u,{recursive:!0},async(e,t)=>{await d.reloadResources(l.supportedLngs||[])}).unref(),await d.use(s).use(c).init({...l,backend:{loadPath:`${u}/{{lng}}/{{ns}}.json`},initAsync:!1,preload:i(u).filter(e=>r(n(u,e)).isDirectory())}),d}export{l as defaultI18nOptions,u as defineI18n};
+import { LOCALES_DIR, PUBLIC_DIR } from "./constants.mjs";
+import { join } from "node:path";
+import { lstatSync, readdirSync, watch } from "node:fs";
+import { createInstance } from "i18next";
+import I18nextFsBackend from "i18next-fs-backend";
+import { initReactI18next } from "react-i18next";
+
+//#region src/api/i18n.ts
+/**
+* Type-safe default options for i18n.
+* Apps should spread these and override as needed.
+*/
+const defaultI18nOptions = {
+	fallbackLng: "en",
+	supportedLngs: ["en"],
+	defaultNS: "translation",
+	ns: ["translation"],
+	interpolation: { escapeValue: false },
+	react: { useSuspense: false }
+};
+/**
+* Initializes i18next for server-side with filesystem backend.
+*
+* @param opts - Initialization options for i18next.
+* @returns A promise that resolves to the initialized i18next instance.
+*/
+async function defineI18n(opts) {
+	const localesDir = join(PUBLIC_DIR, LOCALES_DIR);
+	const i18n$1 = createInstance();
+	if (process.env.NODE_ENV !== "production" && !process.env.VITEST && !process.env.CI) watch(localesDir, { recursive: true }, async (event, fn) => {
+		await i18n$1.reloadResources(opts.supportedLngs || []);
+	}).unref();
+	await i18n$1.use(I18nextFsBackend).use(initReactI18next).init({
+		...opts,
+		backend: { loadPath: `${localesDir}/{{lng}}/{{ns}}.json` },
+		initAsync: false,
+		preload: readdirSync(localesDir).filter((fileName) => {
+			return lstatSync(join(localesDir, fileName)).isDirectory();
+		})
+	});
+	return i18n$1;
+}
+
+//#endregion
+export { defaultI18nOptions, defineI18n };

package/dist/exports/api/index.mjs

@@ -1 +1,20 @@
-import{defineAppContext as e}from"./app-context.mjs";import{auditActionSchema as t,createAccessControl as n,defineAuth as r}from"./auth.mjs";import{defineAuthSchema as i}from"./auth-schema.mjs";import{defineRedisClient as a}from"./redis.mjs";import{defineCache as o}from"./cache.mjs";import{baseSchema as s,defineConfig as c}from"./config.mjs";import{defineAppContainer as l}from"./container.mjs";import{dbChanges as u,defineDatabase as d,defineMigrationOpts as f,defineTestDatabase as p,migrationsSchema as m}from"./database.mjs";import{dbChangeInputSchema as h,dbChangesEvent as g,defineEvent as _,defineEventBus as v,loadEvents as y}from"./event.mjs";import{defaultI18nOptions as b,defineI18n as x}from"./i18n.mjs";import{defineLogger as S}from"./logger.mjs";import{defineMailer as C}from"./mailer.mjs";import{defineMiddleware as w,loadMiddleware as T}from"./middleware.mjs";import{defineOpenAPI as E,defineOpenAPIConfig as D,defineOpenAPIEndpoint as O,defineTypedResponses as k,generateOpenAPIDocument as A,loadAndRegisterAPIRoutes as j,registerRoutes as M,scanAPIRoutes as N,writeOpenAPISpecs as P}from"./openapi.mjs";import{withOtelSpan as F}from"./otel.mjs";import{defineScheduledWorkflow as I,defineWorkflow as L,loadWorkflows as R}from"./workflow.mjs";import{StorageService as z,defineS3Disk as B,defineStorage as V}from"./storage.mjs";import{defineStorageSchema as H}from"./storage-schema.mjs";export{z as StorageService,t as auditActionSchema,s as baseSchema,n as createAccessControl,h as dbChangeInputSchema,u as dbChanges,g as dbChangesEvent,b as defaultI18nOptions,l as defineAppContainer,e as defineAppContext,r as defineAuth,i as defineAuthSchema,o as defineCache,c as defineConfig,d as defineDatabase,_ as defineEvent,v as defineEventBus,x as defineI18n,S as defineLogger,C as defineMailer,w as defineMiddleware,f as defineMigrationOpts,E as defineOpenAPI,D as defineOpenAPIConfig,O as defineOpenAPIEndpoint,a as defineRedisClient,B as defineS3Disk,I as defineScheduledWorkflow,V as defineStorage,H as defineStorageSchema,p as defineTestDatabase,k as defineTypedResponses,L as defineWorkflow,A as generateOpenAPIDocument,j as loadAndRegisterAPIRoutes,y as loadEvents,T as loadMiddleware,R as loadWorkflows,m as migrationsSchema,M as registerRoutes,N as scanAPIRoutes,F as withOtelSpan,P as writeOpenAPISpecs};
+import { defineAppContext } from "./app-context.mjs";
+import { auditActionSchema, createAccessControl, defineAuth } from "./auth.mjs";
+import { defineAuthSchema } from "./auth-schema.mjs";
+import { defineRedisClient } from "./redis.mjs";
+import { defineCache } from "./cache.mjs";
+import { baseSchema, defineConfig } from "./config.mjs";
+import { defineAppContainer } from "./container.mjs";
+import { dbChanges, defineDatabase, defineMigrationOpts, defineTestDatabase, migrationsSchema } from "./database.mjs";
+import { dbChangeInputSchema, dbChangesEvent, defineEvent, defineEventBus, loadEvents } from "./event.mjs";
+import { defaultI18nOptions, defineI18n } from "./i18n.mjs";
+import { defineLogger } from "./logger.mjs";
+import { defineMailer } from "./mailer.mjs";
+import { defineMiddleware, loadMiddleware } from "./middleware.mjs";
+import { defineOpenAPI, defineOpenAPIConfig, defineOpenAPIEndpoint, defineTypedResponses, generateOpenAPIDocument, loadAndRegisterAPIRoutes, registerRoutes, scanAPIRoutes, writeOpenAPISpecs } from "./openapi.mjs";
+import { withOtelSpan } from "./otel.mjs";
+import { defineScheduledWorkflow, defineWorkflow, loadWorkflows } from "./workflow.mjs";
+import { StorageService, defineS3Disk, defineStorage } from "./storage.mjs";
+import { defineStorageSchema } from "./storage-schema.mjs";
+
+export { StorageService, auditActionSchema, baseSchema, createAccessControl, dbChangeInputSchema, dbChanges, dbChangesEvent, defaultI18nOptions, defineAppContainer, defineAppContext, defineAuth, defineAuthSchema, defineCache, defineConfig, defineDatabase, defineEvent, defineEventBus, defineI18n, defineLogger, defineMailer, defineMiddleware, defineMigrationOpts, defineOpenAPI, defineOpenAPIConfig, defineOpenAPIEndpoint, defineRedisClient, defineS3Disk, defineScheduledWorkflow, defineStorage, defineStorageSchema, defineTestDatabase, defineTypedResponses, defineWorkflow, generateOpenAPIDocument, loadAndRegisterAPIRoutes, loadEvents, loadMiddleware, loadWorkflows, migrationsSchema, registerRoutes, scanAPIRoutes, withOtelSpan, writeOpenAPISpecs };

package/dist/exports/api/instrumentation.mjs

@@ -1 +1,40 @@
-import{__reExport as e}from"./_virtual/rolldown_runtime.mjs";import{register as t}from"node:module";import{getNodeAutoInstrumentations as n}from"@opentelemetry/auto-instrumentations-node";import{OTLPTraceExporter as r}from"@opentelemetry/exporter-trace-otlp-http";import{PinoInstrumentation as i}from"@opentelemetry/instrumentation-pino";import{resourceFromAttributes as a}from"@opentelemetry/resources";import{NodeSDK as o}from"@opentelemetry/sdk-node";import{BatchSpanProcessor as s}from"@opentelemetry/sdk-trace-node";import{ATTR_SERVICE_NAME as c,ATTR_SERVICE_VERSION as l}from"@opentelemetry/semantic-conventions";export*from"@opentelemetry/api";var u={};import*as d from"@opentelemetry/api";e(u,d),t(`@opentelemetry/instrumentation/hook.mjs`,import.meta.url);const f={name:process.env.APP_NAME||`appos`,version:process.env.APP_VERSION||`development`};new o({resource:a({[c]:f.name,[l]:f.version}),spanProcessors:[new s(new r({url:process.env.OTEL_EXPORTER_OTLP_ENDPOINT||`http://localhost:4318/v1/traces`,headers:process.env.OTEL_EXPORTER_OTLP_HEADERS?JSON.parse(process.env.OTEL_EXPORTER_OTLP_HEADERS):void 0}))],instrumentations:[n({"@opentelemetry/instrumentation-fs":{enabled:!1},"@opentelemetry/instrumentation-dns":{enabled:!1}}),new i({logHook:(e,t)=>{t[`service.name`]=f.name}})]}).start();export{u as instrumentation_exports};
+import { __reExport } from "./_virtual/rolldown_runtime.mjs";
+import { register } from "node:module";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { PinoInstrumentation } from "@opentelemetry/instrumentation-pino";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+
+export * from "@opentelemetry/api"
+
+//#region src/instrumentation.ts
+var instrumentation_exports = {};
+import * as import__opentelemetry_api from "@opentelemetry/api";
+__reExport(instrumentation_exports, import__opentelemetry_api);
+register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
+const service = {
+	name: process.env.APP_NAME || "appos",
+	version: process.env.APP_VERSION || "development"
+};
+new NodeSDK({
+	resource: resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: service.name,
+		[ATTR_SERVICE_VERSION]: service.version
+	}),
+	spanProcessors: [new BatchSpanProcessor(new OTLPTraceExporter({
+		url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318/v1/traces",
+		headers: process.env.OTEL_EXPORTER_OTLP_HEADERS ? JSON.parse(process.env.OTEL_EXPORTER_OTLP_HEADERS) : void 0
+	}))],
+	instrumentations: [getNodeAutoInstrumentations({
+		"@opentelemetry/instrumentation-fs": { enabled: false },
+		"@opentelemetry/instrumentation-dns": { enabled: false }
+	}), new PinoInstrumentation({ logHook: (_span, record) => {
+		record["service.name"] = service.name;
+	} })]
+}).start();
+
+//#endregion
+export { instrumentation_exports };

package/dist/exports/api/logger.mjs

@@ -1 +1,26 @@
-import e from"pino";import t from"pino-pretty";async function n(n){let r=[],i={level:n.level||`info`,redact:n.redact||[],...r.length>0&&{transport:r.length===1?r[0]:{targets:r}}};try{return e(i,process.env.NODE_ENV!==`production`&&!process.env.VITEST?t():void 0)}catch{return e(i)}}export{n as defineLogger};
+import pino from "pino";
+import pinoPretty from "pino-pretty";
+
+//#region src/api/logger.ts
+/**
+* Define the logger instance.
+*
+* @param opts - The options.
+* @returns The logger.
+*/
+async function defineLogger(opts) {
+	const transports = [];
+	const commonOpts = {
+		level: opts.level || "info",
+		redact: opts.redact || [],
+		...transports.length > 0 && { transport: transports.length === 1 ? transports[0] : { targets: transports } }
+	};
+	try {
+		return pino(commonOpts, process.env.NODE_ENV !== "production" && !process.env.VITEST ? pinoPretty() : void 0);
+	} catch (_) {
+		return pino(commonOpts);
+	}
+}
+
+//#endregion
+export { defineLogger };

package/dist/exports/api/mailer.mjs

@@ -1 +1,37 @@
-import{render as e}from"@react-email/render";import{createTransport as t}from"nodemailer";function n({from:n,smtpUrl:r}){let i=t({url:r});return{async send(t){let r,a,o;if(`react`in t){[r,a]=await Promise.all([e(t.react),e(t.react,{plainText:!0})]);let{react:n,...i}=t;o=i}else{r=t.html,a=t.text;let{html:e,text:n,...i}=t;o=i}await i.sendMail({from:t.from||n,...o,html:r,text:a})}}}export{n as defineMailer};
+import { render } from "@react-email/render";
+import { createTransport } from "nodemailer";
+
+//#region src/api/mailer.ts
+/**
+* Define the mailer.
+*
+* @param env - The environment variables.
+* @returns The mailer.
+*/
+function defineMailer({ from, smtpUrl }) {
+	const mailer = createTransport({ url: smtpUrl });
+	return { async send(payload) {
+		let html;
+		let text;
+		let mailOptions;
+		if ("react" in payload) {
+			[html, text] = await Promise.all([render(payload.react), render(payload.react, { plainText: true })]);
+			const { react: _, ...rest } = payload;
+			mailOptions = rest;
+		} else {
+			html = payload.html;
+			text = payload.text;
+			const { html: _, text: __, ...rest } = payload;
+			mailOptions = rest;
+		}
+		await mailer.sendMail({
+			from: payload.from || from,
+			...mailOptions,
+			html,
+			text
+		});
+	} };
+}
+
+//#endregion
+export { defineMailer };

package/dist/exports/api/middleware.mjs

@@ -1 +1,73 @@
-import{FILE_EXT as e}from"./constants.mjs";import{basename as t}from"node:path";import n,{glob as r}from"node:fs/promises";import{camelCase as i}from"es-toolkit";function a(e){return{name:e.name??null,handler:e.handler}}function o(e){return i(t(e,`.ts`).replace(/^\d+_/,``))}async function s(i,a,s){try{await n.access(i)}catch{return}let c=[];for await(let t of r(`${i}/**/*.${e}`))!t.endsWith(`.test.ts`)&&!t.endsWith(`.spec.ts`)&&!t.endsWith(`.test.js`)&&!t.endsWith(`.spec.js`)&&c.push(t);c.sort((e,n)=>t(e).localeCompare(t(n)));for(let e of c)try{let t=(await import(e)).default;if(t&&typeof t.handler==`function`){let n=t.name??o(e);a.logger.debug({name:n,file:e},`Loading user middleware`),s.use(t.handler(a))}else a.logger.warn({file:e},`Middleware file missing default export with handler function`)}catch(t){throw a.logger.error({file:e,error:t instanceof Error?t.message:t},`Failed to load middleware`),t}}export{a as defineMiddleware,s as loadMiddleware};
+import { FILE_EXT } from "./constants.mjs";
+import { basename } from "node:path";
+import fs, { glob } from "node:fs/promises";
+import { camelCase } from "es-toolkit";
+
+//#region src/api/middleware.ts
+/**
+* Defines a user middleware loaded from api/middleware/ directory.
+*
+* Use numeric prefixes (000_, 001_, etc.) to control load order.
+*
+* @example
+* // api/middleware/000_custom-auth.ts
+* export default defineMiddleware({
+*   handler: (container) => (req, res, next) => {
+*     // Custom logic using container
+*     next();
+*   },
+* });
+*/
+function defineMiddleware(config) {
+	return {
+		name: config.name ?? null,
+		handler: config.handler
+	};
+}
+/**
+* Extracts middleware name from filename, removing numeric prefix.
+* "000_custom-auth.ts" -> "customAuth"
+*/
+function getMiddlewareName(filename) {
+	return camelCase(basename(filename, ".ts").replace(/^\d+_/, ""));
+}
+/**
+* Loads user middleware from a directory and registers them with the app.
+*
+* Middleware files are loaded in alphabetical order by filename.
+* Use numeric prefixes (000_, 001_, etc.) to control the load order.
+*
+* @param middlewareDir - The directory containing middleware files
+* @param container - The application container
+* @param app - The Express application instance
+*/
+async function loadMiddleware(middlewareDir, container, app) {
+	try {
+		await fs.access(middlewareDir);
+	} catch {
+		return;
+	}
+	const files = [];
+	for await (const file of glob(`${middlewareDir}/**/*.${FILE_EXT}`)) if (!file.endsWith(".test.ts") && !file.endsWith(".spec.ts") && !file.endsWith(".test.js") && !file.endsWith(".spec.js")) files.push(file);
+	files.sort((a, b) => basename(a).localeCompare(basename(b)));
+	for (const file of files) try {
+		const middleware = (await import(file)).default;
+		if (middleware && typeof middleware.handler === "function") {
+			const name = middleware.name ?? getMiddlewareName(file);
+			container.logger.debug({
+				name,
+				file
+			}, "Loading user middleware");
+			app.use(middleware.handler(container));
+		} else container.logger.warn({ file }, "Middleware file missing default export with handler function");
+	} catch (err) {
+		container.logger.error({
+			file,
+			error: err instanceof Error ? err.message : err
+		}, "Failed to load middleware");
+		throw err;
+	}
+}
+
+//#endregion
+export { defineMiddleware, loadMiddleware };