appos 0.2.1 → 0.2.3-0

package/dist/exports/api/mailer.d.mts

@@ -0,0 +1,70 @@
+import Mail from "nodemailer/lib/mailer/index.ts";
+import { JSX } from "react";
+
+//#region src/api/mailer.d.ts
+
+/**
+ * The mailer type.
+ */
+type Mailer = ReturnType<typeof defineMailer>;
+/**
+ * The mailer payload type with React component.
+ */
+type MailerPayloadReact = Omit<Mail.Options, "from" | "html" | "text"> & {
+  /**
+   * The email address to send the email from.
+   */
+  from?: string;
+  /**
+   * The React component to render as the email body.
+   */
+  react: JSX.Element;
+};
+/**
+ * The mailer payload type with direct HTML and text.
+ */
+type MailerPayloadHtml = Omit<Mail.Options, "from"> & {
+  /**
+   * The email address to send the email from.
+   */
+  from?: string;
+  /**
+   * The HTML content of the email.
+   */
+  html: string;
+  /**
+   * The plain text content of the email.
+   */
+  text: string;
+};
+/**
+ * The mailer payload type - supports either React component or direct HTML+text.
+ */
+type MailerPayload = MailerPayloadReact | MailerPayloadHtml;
+/**
+ * Define the options for the mailer.
+ */
+interface DefineMailerOptions {
+  /**
+   * The default email address to use as the sender.
+   */
+  from: string;
+  /**
+   * The SMTP URL to use for sending emails.
+   */
+  smtpUrl: string;
+}
+/**
+ * Define the mailer.
+ *
+ * @param env - The environment variables.
+ * @returns The mailer.
+ */
+declare function defineMailer({
+  from,
+  smtpUrl
+}: DefineMailerOptions): {
+  send(payload: MailerPayload): Promise<void>;
+};
+//#endregion
+export { DefineMailerOptions, Mailer, MailerPayload, MailerPayloadHtml, MailerPayloadReact, defineMailer };

package/dist/exports/api/mailer.mjs

@@ -0,0 +1 @@
+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};

package/dist/exports/api/middleware/request-logger.d.mts

@@ -0,0 +1,24 @@
+import "../logger.mjs";
+import { RequestHandler } from "ultimate-express";
+
+//#region src/api/middleware/request-logger.d.ts
+
+/**
+ * Metadata about the HTTP request.
+ */
+interface RequestMetadata {
+  /**
+   * Client's IP address from X-Forwarded-For or RemoteAddr.
+   */
+  ipAddress: string;
+  /**
+   * Client's User-Agent header.
+   */
+  userAgent: string;
+  /**
+   * Client IP's country from CF-IPCountry header.
+   */
+  country: string;
+}
+//#endregion
+export { RequestMetadata };

package/dist/exports/api/middleware.d.mts

@@ -0,0 +1,39 @@
+import { AppContainer } from "./container.mjs";
+import { Express, RequestHandler } from "ultimate-express";
+
+//#region src/api/middleware.d.ts
+interface Middleware {
+  name: string | null;
+  handler: (container: AppContainer) => RequestHandler;
+}
+/**
+ * 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();
+ *   },
+ * });
+ */
+declare function defineMiddleware(config: {
+  name?: string;
+  handler: (container: AppContainer) => RequestHandler;
+}): Middleware;
+/**
+ * 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
+ */
+declare function loadMiddleware(middlewareDir: string, container: AppContainer, app: Express): Promise<void>;
+//#endregion
+export { Middleware, defineMiddleware, loadMiddleware };

package/dist/exports/api/middleware.mjs

@@ -0,0 +1 @@
+import{camelCase as e}from"./node_modules/.bun/change-case@5.4.4/node_modules/change-case/dist/index.mjs";import{basename as t}from"node:path";import n,{glob as r}from"node:fs/promises";function i(e){return{name:e.name??null,handler:e.handler}}function a(n){return e(t(n,`.ts`).replace(/^\d+_/,``))}async function o(e,i,o){try{await n.access(e)}catch{return}let s=[];for await(let t of r(`${e}/**/*.ts`))!t.endsWith(`.test.ts`)&&!t.endsWith(`.spec.ts`)&&s.push(t);s.sort((e,n)=>t(e).localeCompare(t(n)));for(let e of s)try{let t=(await import(e)).default;if(t&&typeof t.handler==`function`){let n=t.name??a(e);i.logger.debug({name:n,file:e},`Loading user middleware`),o.use(t.handler(i))}else i.logger.warn({file:e},`Middleware file missing default export with handler function`)}catch(t){throw i.logger.error({file:e,error:t instanceof Error?t.message:t},`Failed to load middleware`),t}}export{i as defineMiddleware,o as loadMiddleware};

package/dist/exports/api/node_modules/.bun/change-case@5.4.4/node_modules/change-case/dist/index.mjs

@@ -0,0 +1 @@
+const e=/([\p{Ll}\d])(\p{Lu})/gu,t=/(\p{Lu})([\p{Lu}][\p{Ll}])/gu,n=/(\d)\p{Ll}|(\p{L})\d/u,r=/[^\p{L}\d]+/giu,i=`$1\0$2`;function a(n){let a=n.trim();a=a.replace(e,i).replace(t,i),a=a.replace(r,`\0`);let o=0,s=a.length;for(;a.charAt(o)===`\0`;)o++;if(o===s)return[];for(;a.charAt(s-1)===`\0`;)s--;return a.slice(o,s).split(/\0/g)}function o(e){let t=a(e);for(let e=0;e<t.length;e++){let r=t[e],i=n.exec(r);if(i){let n=i.index+(i[1]??i[2]).length;t.splice(e,1,r.slice(0,n),r.slice(n))}}return t}function s(e,t){let[n,r,i]=f(e,t),a=c(t?.locale),o=l(t?.locale),s=t?.mergeAmbiguousCharacters?u(a,o):d(a,o);return n+r.map((e,t)=>t===0?a(e):s(e,t)).join(t?.delimiter??``)+i}function c(e){return e===!1?e=>e.toLowerCase():t=>t.toLocaleLowerCase(e)}function l(e){return e===!1?e=>e.toUpperCase():t=>t.toLocaleUpperCase(e)}function u(e,t){return n=>`${t(n[0])}${e(n.slice(1))}`}function d(e,t){return(n,r)=>{let i=n[0];return(r>0&&i>=`0`&&i<=`9`?`_`+i:t(i))+e(n.slice(1))}}function f(e,t={}){let n=t.split??(t.separateNumbers?o:a),r=t.prefixCharacters??``,i=t.suffixCharacters??``,s=0,c=e.length;for(;s<e.length;){let t=e.charAt(s);if(!r.includes(t))break;s++}for(;c>s;){let t=c-1,n=e.charAt(t);if(!i.includes(n))break;c=t}return[e.slice(0,s),n(e.slice(s,c)),e.slice(c)]}export{s as camelCase};

package/dist/exports/api/openapi.d.mts

@@ -0,0 +1,271 @@
+import { Container } from "./container.mjs";
+import { AppContext } from "./app-context.mjs";
+import { z } from "zod";
+import { Express, Request, RequestHandler } from "ultimate-express";
+import * as _node_modules_zod_openapi_dist_components_B1DX_zYv_mjs0 from "#node_modules/zod-openapi/dist/components-B1DX_zYv.mjs";
+
+//#region src/api/openapi.d.ts
+declare const appDir: string;
+/**
+ * Utility type to enforce exact type matching (no extra properties).
+ * This uses a tuple check to prevent objects with extra keys from being assigned.
+ * Arrays are handled specially to avoid treating numeric indices as object keys.
+ */
+type Exact<T, Expected> = [T] extends [Expected] ? [Expected] extends [T] ? T : T extends readonly unknown[] ? Expected extends readonly unknown[] ? T extends readonly (infer TItem)[] ? Expected extends readonly (infer ExpectedItem)[] ? readonly Exact<TItem, ExpectedItem>[] : T : T : { [K in keyof T]: K extends keyof Expected ? Exact<T[K], Expected[K]> : ["Error: unexpected key", K] } : { [K in keyof T]: K extends keyof Expected ? Exact<T[K], Expected[K]> : ["Error: unexpected key", K] } : T;
+/**
+ * Response marker type for Express compatibility.
+ */
+type ResponseMarker<T = unknown> = {
+  __response: true;
+  status: number;
+  data: T;
+};
+/**
+ * Define typed response builders based on defined response schemas.
+ */
+declare function defineTypedResponses<TResponses extends Record<number, {
+  description: string;
+  schema: z.ZodSchema;
+}>>(responses: TResponses): { [K in keyof TResponses as GetMethodName<K>]: K extends number ? TResponses[K]["schema"] extends z.ZodNull ? () => ResponseMarker<null> : <T extends z.infer<TResponses[K]["schema"]>>(data: Exact<T, z.infer<TResponses[K]["schema"]>>) => ResponseMarker<z.infer<TResponses[K]["schema"]>> : never } & {
+  status: <S extends keyof TResponses & number>(statusCode: S, data: TResponses[S]["schema"] extends z.ZodNull ? undefined : Exact<z.infer<TResponses[S]["schema"]>, z.infer<TResponses[S]["schema"]>>) => ResponseMarker;
+};
+type GetMethodName<K$1> = K$1 extends 200 ? "ok" : K$1 extends 201 ? "created" : K$1 extends 202 ? "accepted" : K$1 extends 204 ? "noContent" : K$1 extends 400 ? "badRequest" : K$1 extends 401 ? "unauthorized" : K$1 extends 403 ? "forbidden" : K$1 extends 404 ? "notFound" : K$1 extends 409 ? "conflict" : K$1 extends 422 ? "unprocessableEntity" : K$1 extends 500 ? "internalServerError" : never;
+/**
+ * Handler parameters with full type safety for request inputs.
+ */
+type HandlerParams<TParams extends z.ZodSchema | undefined = undefined, TQuery extends z.ZodSchema | undefined = undefined, TBody extends z.ZodSchema | undefined = undefined, THeaders extends z.ZodSchema | undefined = undefined, TResponses extends Record<number, {
+  description: string;
+  schema: z.ZodSchema;
+}> = Record<number, {
+  description: string;
+  schema: z.ZodSchema;
+}>> = {
+  ctx: AppContext;
+  body: TBody extends z.ZodSchema ? z.infer<TBody> : unknown;
+  headers: THeaders extends z.ZodSchema ? z.infer<THeaders> : Record<string, string>;
+  params: TParams extends z.ZodSchema ? z.infer<TParams> : Record<string, unknown>;
+  query: TQuery extends z.ZodSchema ? z.infer<TQuery> : Record<string, unknown>;
+  request: Request;
+  response: ReturnType<typeof defineTypedResponses<TResponses>>;
+};
+/**
+ * Helper function to define an OpenAPI endpoint with full type safety.
+ */
+declare function defineOpenAPIEndpoint<TParams extends z.ZodSchema | undefined = undefined, TQuery extends z.ZodSchema | undefined = undefined, TBody extends z.ZodSchema | undefined = undefined, THeaders extends z.ZodSchema | undefined = undefined, TResponses extends Record<number, {
+  description: string;
+  schema: z.ZodSchema;
+}> = Record<number, {
+  description: string;
+  schema: z.ZodSchema;
+}>>(spec: {
+  summary?: string;
+  description?: string;
+  params?: TParams;
+  query?: TQuery;
+  requestBody?: TBody;
+  headers?: THeaders;
+  responses: TResponses;
+  handler: (params: HandlerParams<TParams, TQuery, TBody, THeaders, TResponses>) => Promise<ResponseMarker>;
+}): {
+  summary?: string;
+  description?: string;
+  params?: TParams;
+  query?: TQuery;
+  requestBody?: TBody;
+  headers?: THeaders;
+  responses: TResponses;
+  handler: (params: HandlerParams<TParams, TQuery, TBody, THeaders, TResponses>) => Promise<ResponseMarker>;
+};
+/**
+ * OpenAPI method specification type (for internal use).
+ */
+type OpenAPIMethodSpec = {
+  summary?: string;
+  description?: string;
+  params?: z.ZodSchema;
+  query?: z.ZodSchema;
+  requestBody?: z.ZodSchema;
+  headers?: z.ZodSchema;
+  responses: Record<number, {
+    description: string;
+    schema: z.ZodSchema;
+  }>;
+  handler: (params: HandlerParams<any, any, any, any, any>) => Promise<ResponseMarker>;
+};
+/**
+ * Configuration object for defineOpenApi.
+ */
+type DefineOpenAPIConfig = { [K in "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE"]?: OpenAPIMethodSpec };
+/**
+ * OpenAPI configuration for document-level settings
+ */
+type OpenAPIObjectConfigV31 = {
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+    contact?: {
+      name?: string;
+      email?: string;
+      url?: string;
+    };
+    license?: {
+      name: string;
+      url?: string;
+    };
+  };
+  servers?: Array<{
+    url: string;
+    description?: string;
+  }>;
+  openapi: "3.1.0";
+};
+/**
+ * Simplified config input for defineOpenAPIConfig
+ */
+type DefineOpenAPIConfigInput = {
+  info: OpenAPIObjectConfigV31["info"];
+  servers?: OpenAPIObjectConfigV31["servers"];
+};
+/**
+ * OpenAPI registration format (without path - CLI will add it)
+ */
+type OpenAPIRegistration = {
+  method: "get" | "post" | "put" | "patch" | "delete" | "head";
+  summary?: string;
+  description?: string;
+  request?: {
+    params?: z.ZodSchema;
+    query?: z.ZodSchema;
+    body?: z.ZodSchema;
+    headers?: z.ZodSchema;
+  };
+  responses: Record<number, {
+    description: string;
+    content: {
+      "application/json": {
+        schema: z.ZodSchema;
+      };
+    };
+  }>;
+};
+/**
+ * Return type for defineOpenAPI function
+ */
+type DefineOpenAPIReturn = {
+  handlers: Record<string, RequestHandler>;
+  openAPISpec: OpenAPIRegistration[];
+};
+/**
+ * RFC 9457 compliant validation error response
+ */
+type ValidationErrorResponse = {
+  error: "validation_error";
+  status: number;
+  detail: string;
+  errors: Array<{
+    field: string;
+    message: string;
+    received: unknown;
+  }>;
+};
+/**
+ * Define OpenAPI-based route handlers with full type safety.
+ *
+ * @param config Configuration object with HTTP method specifications
+ * @returns Object containing Express handlers and openAPISpec
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * export default defineOpenAPI({
+ *   GET: {
+ *     summary: "Get user by ID",
+ *     params: z.object({ id: z.uuid() }),
+ *     responses: {
+ *       200: { description: "User data", schema: UserSchema }
+ *     },
+ *     handler: async ({ params, response }) => {
+ *       const user = await getUser(params.id);
+ *       return response.ok(user); // Fully typed!
+ *     }
+ *   },
+ *   POST: {
+ *     summary: "Create user",
+ *     requestBody: CreateUserSchema,
+ *     responses: {
+ *       201: { description: "User created", schema: UserSchema }
+ *     },
+ *     handler: async ({ body, response }) => {
+ *       const user = await createUser(body);
+ *       return response.created(user); // Fully typed!
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function defineOpenAPI(config: DefineOpenAPIConfig): DefineOpenAPIReturn;
+/**
+ * Define OpenAPI document configuration with improved DX.
+ *
+ * Only allows specifying info and servers objects, ensuring a consistent
+ * OpenAPI v3.1.0 structure while preventing configuration of other fields.
+ *
+ * @param config Configuration object with info and optional servers
+ * @returns Complete OpenAPI configuration object
+ *
+ * @example
+ * ```typescript
+ * export const openAPIConfig = defineOpenAPIConfig({
+ *   info: {
+ *     title: "My API",
+ *     version: "1.0.0",
+ *     description: "API v1 - Authentication and core features",
+ *     contact: {
+ *       name: "API Support",
+ *       email: "support@example.com",
+ *     },
+ *   },
+ *   servers: [
+ *     {
+ *       url: process.env.API_URL || "http://localhost:8000",
+ *       description: "API Server",
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineOpenAPIConfig<TContainer extends Container = Container>(config: (container: TContainer) => DefineOpenAPIConfigInput): (container: TContainer) => OpenAPIObjectConfigV31;
+/**
+ * Route module type for scanned API routes
+ */
+type RouteModule = {
+  path: string;
+  filePath: string;
+  handlers: Record<string, RequestHandler>;
+  openAPISpec: OpenAPIRegistration[];
+  version?: string;
+};
+/**
+ * Generate complete OpenAPI 3.1.0 document from routes using zod-openapi
+ */
+declare function generateOpenAPIDocument(routes: RouteModule[], version: string, config?: DefineOpenAPIConfigInput): _node_modules_zod_openapi_dist_components_B1DX_zYv_mjs0.it;
+/**
+ * Scan routes directory and convert to Express route paths using remix-flat-routes.
+ */
+declare function scanAPIRoutes(container: Container): Promise<RouteModule[]>;
+/**
+ * Register scanned routes with Express app.
+ */
+declare function registerRoutes(app: Express, routes: RouteModule[]): void;
+/**
+ * Write OpenAPI specs to api/public/openapi directory.
+ */
+declare function writeOpenAPISpecs<TContainer extends Container>(container: TContainer, routes: RouteModule[]): Promise<void>;
+/**
+ * Load and register API routes with Express (convenience function).
+ * Also auto-generates OpenAPI specs in development mode.
+ */
+declare function loadAndRegisterAPIRoutes<TContainer extends Container>(app: Express): Promise<void>;
+//#endregion
+export { DefineOpenAPIConfig, DefineOpenAPIConfigInput, DefineOpenAPIReturn, HandlerParams, OpenAPIMethodSpec, OpenAPIObjectConfigV31, OpenAPIRegistration, RouteModule, ValidationErrorResponse, appDir, defineOpenAPI, defineOpenAPIConfig, defineOpenAPIEndpoint, defineTypedResponses, generateOpenAPIDocument, loadAndRegisterAPIRoutes, registerRoutes, scanAPIRoutes, writeOpenAPISpecs };

package/dist/exports/api/openapi.mjs

@@ -0,0 +1 @@
+import{defineAppContext as e}from"./app-context.mjs";import{PUBLIC_DIR as t}from"./packages/appos/src/constants.mjs";import{z as n}from"zod";import{join as r,resolve as i}from"node:path";import{access as a,mkdir as o,writeFile as s}from"node:fs/promises";import{remixRoutesOptionAdapter as c}from"@react-router/remix-routes-option-adapter";import{isEmpty as l}from"es-toolkit/compat";import{flatRoutes as u}from"remix-flat-routes";import{createDocument as d}from"zod-openapi";const f=`${process.env.NODE_ENV===`production`?`./build`:`.`}`,p=`routes`,m=i(`${f}/${t}/openapi`);function h(e){let t={};for(let[r,i]of Object.entries(e)){let e=Number(r),a=g(e);a&&(t[a]=t=>{let r=i.schema;if(r instanceof n.ZodNull||t==null)return{__response:!0,status:e,data:t??null};try{let i=r;if(r instanceof n.ZodObject)i=r.strict();else if(r instanceof n.ZodArray){let e=r.element;e instanceof n.ZodObject&&(i=n.array(e.strict()))}return{__response:!0,status:e,data:i.parse(t)}}catch(r){throw r instanceof n.ZodError?Error(`Response validation failed for status ${e}: ${JSON.stringify(r.issues,null,2)}\n\nData provided: ${JSON.stringify(t,null,2)}`):r}})}return t.status=(t,r)=>{let i=Number(t),a=e[t];if(!a)return{__response:!0,status:i,data:r??null};let o=a.schema;if(!o||o instanceof n.ZodNull||r==null)return{__response:!0,status:i,data:r??null};try{let e=o;if(o instanceof n.ZodObject)e=o.strict();else if(o instanceof n.ZodArray){let t=o.element;t instanceof n.ZodObject&&(e=n.array(t.strict()))}return{__response:!0,status:i,data:e.parse(r)}}catch(e){throw e instanceof n.ZodError?Error(`Response validation failed for status ${i}: ${JSON.stringify(e.issues,null,2)}\n\nData provided: ${JSON.stringify(r,null,2)}`):e}},t}function g(e){return{200:`ok`,201:`created`,202:`accepted`,204:`noContent`,400:`badRequest`,401:`unauthorized`,403:`forbidden`,404:`notFound`,409:`conflict`,422:`unprocessableEntity`,500:`internalServerError`}[e]||null}function _(e){return e}function v(e,t){return e?e.parse(t):t}function y(e,t){let n={};for(let[e,r]of t.searchParams.entries()){let t=n[e];t===void 0?n[e]=r:Array.isArray(t)?t.push(r):n[e]=[t,r]}return e?e.parse(n):n}function b(e,t){let n=t.body;return e?e.parse(n):n}function x(e,t){let n=t.headers;return e?e.parse(n):n}function S(e){switch(e){case`params`:case`query`:case`headers`:return 400;case`body`:return 422;default:return 400}}function C(e,t){let n=S(t);return{__response:!0,status:n,data:{error:`validation_error`,status:n,detail:`Request validation failed`,errors:e.issues.map(e=>({field:e.path.join(`.`),message:e.message,received:`received`in e?e.received:e.input}))}}}function w(t,r){return async(i,a,o)=>{try{let n=new URL(i.url||`/`,`http://${i.headers.host}`),r=v(t.params,i.params),o=y(t.query,n),s=b(t.requestBody,i),c=x(t.headers,i),l=h(t.responses),u=await e({apiKey:i.apiKey,container:i.app.locals.container,request:i,fetchSession:!1}),d=await t.handler({ctx:u,body:s,headers:c,params:r,query:o,request:i,response:l});if(d&&typeof d==`object`&&`__response`in d){let e=d;e.data===null||e.data===void 0?a.status(e.status).end():a.status(e.status).json(e.data)}else a.status(200).json(d)}catch(e){if(e instanceof n.ZodError){let t=C(e,r===`GET`||r===`HEAD`?`query`:`body`);a.status(t.status).json(t.data)}else o(e)}}}function T(e){let t=[];for(let n of[`GET`,`HEAD`,`POST`,`PUT`,`PATCH`,`DELETE`]){let r=e[n];if(!r)continue;let i={};r.params&&(i.params=r.params),r.query&&(i.query=r.query),r.requestBody&&(i.body=r.requestBody),r.headers&&(i.headers=r.headers);let a={};for(let[e,t]of Object.entries(r.responses))a[Number(e)]={description:t.description,content:{"application/json":{schema:t.schema}}};t.push({method:n.toLowerCase(),summary:r.summary,description:r.description,request:Object.keys(i).length>0?i:void 0,responses:a})}return t}function E(e){let t={};for(let n of[`GET`,`HEAD`,`POST`,`PUT`,`PATCH`,`DELETE`]){let r=e[n];r&&(t[n]=w(r,n))}return{handlers:t,openAPISpec:T(e)}}function D(e){return t=>{let n=e(t);return{info:n.info,servers:n.servers,openapi:`3.1.0`}}}function O(e){return e.match(/^\/(v\d+)/)?.[1]}function k(e){return e.replace(/:(\w+)/g,`{$1}`)}function A(e,t){let n=k(e),r={summary:t.summary,description:t.description};(t.request?.params||t.request?.query||t.request?.headers)&&(r.requestParams={},t.request.params&&(r.requestParams.path=t.request.params),t.request.query&&(r.requestParams.query=t.request.query),t.request.headers&&(r.requestParams.header=t.request.headers)),t.request?.body&&(r.requestBody={content:{"application/json":{schema:t.request.body}}}),r.responses={};for(let[e,n]of Object.entries(t.responses))r.responses[e]={description:n.description,content:{"application/json":{schema:n.content[`application/json`].schema}}};return{path:n,config:r}}function j(e,t,n){let r={};for(let n of e){if(n.version!==t)continue;let e=n.path.replace(`/${t}`,``)||`/`;for(let t of n.openAPISpec){let{path:n,config:i}=A(e,t);r[n]||(r[n]={}),r[n][t.method]=i}}return d({openapi:`3.1.0`,info:n?.info||{title:`API ${t.toUpperCase()}`,version:t.replace(`v`,``),description:`OpenAPI specification for ${t} API`},servers:n?.servers||[{url:`http://localhost:8000/${t}`,description:process.env.NODE_ENV===`production`?`Production server`:`Development server`}],paths:r})}async function M(e){let t=i(`${f}/${p}`);try{await a(t)}catch(t){return e.logger.error({error:t},`OpenAPI routes directory not found`),[]}let n=await c(e=>u(p,e,{appDir:f,ignoredRouteFiles:[`**/.*`,`**/*.{spec,test}.{ts,tsx}`,`**/*-????????.{js,ts}`]})),r=[];for(let[t,a]of Object.entries(n)){let t=i(`${f}/${a.file}`).replace(/.ts$/,process.env.NODE_ENV===`production`?`.js`:`.ts`);try{let n=(await import(t)).default;if(!n||l(n)||/\/openapi.(j|t)s$/.test(t))continue;if(!n?.handlers&&!n?.openAPISpec){e.logger.warn(`Missing default export with 'defineOpenAPI' for '${f}/${a.file}'`);continue}let i=`/${a.path}`;e.logger.info(`Registering route: ${i} from ${a.file}`),r.push({path:i,filePath:t,handlers:n.handlers,openAPISpec:n.openAPISpec,version:O(i)})}catch(t){e.logger.error(t,`Error loading route ${a.file}:`)}}return r}function N(e,t){for(let n of t)for(let[t,r]of Object.entries(n.handlers))e[t.toLowerCase()](n.path,r)}async function P(e,t){let n=i(`${f}/${p}/${t}+/openapi.ts`);try{let t=(await import(n)).default;return t?t(e):void 0}catch{return}}async function F(e,t){let n=[...new Set(t.map(e=>e.version).filter(Boolean))];n.length>0&&await o(m,{recursive:!0});for(let i of n){let n=j(t,i,await P(e,i));await s(r(m,`${i}.json`),JSON.stringify(n,null,2),`utf-8`)}}async function I(e){let t=await M(e.locals.container);N(e,t),process.env.NODE_ENV!==`production`&&await F(e.locals.container,t)}export{f as appDir,E as defineOpenAPI,D as defineOpenAPIConfig,_ as defineOpenAPIEndpoint,h as defineTypedResponses,j as generateOpenAPIDocument,I as loadAndRegisterAPIRoutes,N as registerRoutes,M as scanAPIRoutes,F as writeOpenAPISpecs};

package/dist/exports/api/orm.d.mts

@@ -0,0 +1,13 @@
+import { __export, __reExport } from "./_virtual/rolldown_runtime.mjs";
+import { index, isPgEnum, isPgMaterializedView, isPgSchema, isPgSequence, isPgView, numeric, parsePgArray, parsePgNestedArray, pgEnum, pgMaterializedView, pgPolicy, pgRole, pgSchema, pgSequence, pgTable, pgTableCreator, pgView, serial, smallint, smallserial, sparsevec, unique, uniqueIndex, uniqueKeyName, withReplicas } from "drizzle-orm/pg-core";
+export * from "drizzle-orm";
+export * from "drizzle-seed";
+
+//#region src/api/orm.d.ts
+declare namespace orm_d_exports {
+  export { index, isPgEnum, isPgMaterializedView, isPgSchema, isPgSequence, isPgView, numeric, parsePgArray, parsePgNestedArray, pgEnum, pgMaterializedView, pgPolicy, pgRole, pgSchema, pgSequence, pgTable, pgTableCreator, pgView, serial, smallint, smallserial, sparsevec, unique, uniqueIndex, uniqueKeyName, withReplicas };
+}
+import * as import_drizzle_orm from "drizzle-orm";
+import * as import_drizzle_seed from "drizzle-seed";
+//#endregion
+export { index, isPgEnum, isPgMaterializedView, isPgSchema, isPgSequence, isPgView, numeric, orm_d_exports, parsePgArray, parsePgNestedArray, pgEnum, pgMaterializedView, pgPolicy, pgRole, pgSchema, pgSequence, pgTable, pgTableCreator, pgView, serial, smallint, smallserial, sparsevec, unique, uniqueIndex, uniqueKeyName, withReplicas };

package/dist/exports/api/orm.mjs

@@ -0,0 +1 @@
+import{__export as e,__reExport as t}from"./_virtual/rolldown_runtime.mjs";import{index as n,isPgEnum as r,isPgMaterializedView as i,isPgSchema as a,isPgSequence as o,isPgView as s,numeric as c,parsePgArray as l,parsePgNestedArray as u,pgEnum as d,pgMaterializedView as f,pgPolicy as p,pgRole as m,pgSchema as h,pgSequence as g,pgTable as _,pgTableCreator as v,pgView as y,serial as b,smallint as x,smallserial as S,sparsevec as C,unique as w,uniqueIndex as T,uniqueKeyName as E,withReplicas as D}from"drizzle-orm/pg-core";export*from"drizzle-orm";export*from"drizzle-seed";var O=e({index:()=>n,isPgEnum:()=>r,isPgMaterializedView:()=>i,isPgSchema:()=>a,isPgSequence:()=>o,isPgView:()=>s,numeric:()=>c,parsePgArray:()=>l,parsePgNestedArray:()=>u,pgEnum:()=>d,pgMaterializedView:()=>f,pgPolicy:()=>p,pgRole:()=>m,pgSchema:()=>h,pgSequence:()=>g,pgTable:()=>_,pgTableCreator:()=>v,pgView:()=>y,serial:()=>b,smallint:()=>x,smallserial:()=>S,sparsevec:()=>C,unique:()=>w,uniqueIndex:()=>T,uniqueKeyName:()=>E,withReplicas:()=>D});import*as k from"drizzle-orm";t(O,k);import*as A from"drizzle-seed";t(O,A);export{n as index,r as isPgEnum,i as isPgMaterializedView,a as isPgSchema,o as isPgSequence,s as isPgView,c as numeric,O as orm_exports,l as parsePgArray,u as parsePgNestedArray,d as pgEnum,f as pgMaterializedView,p as pgPolicy,m as pgRole,h as pgSchema,g as pgSequence,_ as pgTable,v as pgTableCreator,y as pgView,b as serial,x as smallint,S as smallserial,C as sparsevec,w as unique,T as uniqueIndex,E as uniqueKeyName,D as withReplicas};

package/dist/exports/api/otel.d.mts

@@ -0,0 +1,40 @@
+import { instrumentation_d_exports } from "./packages/appos/src/instrumentation.mjs";
+
+//#region src/api/otel.d.ts
+
+/**
+ * Wraps an async function with an OpenTelemetry span for distributed tracing.
+ *
+ * Automatically handles span lifecycle (start/end), error recording, and context propagation.
+ * The span will appear as a child of the currently active span (if any).
+ *
+ * @param tracerName - Fully qualified module path (e.g., "api/routes/payouts", "packages/primitives/mailer")
+ * @param spanName - Operation name following {verb} {object} pattern (e.g., "fetch payouts", "send email")
+ * @param fn - The async function to execute within the span context. Receives span for custom attributes.
+ * @param attributes - Optional span attributes for high-cardinality data (IDs, counts, etc.).
+ *                     Use semantic conventions: https://opentelemetry.io/docs/specs/semconv/
+ * @returns Promise resolving to the function's return value.
+ *
+ * @example
+ * // Basic usage - simple business operation
+ * await withOtelSpan("api/routes/payouts", "fetch payouts", async () => {
+ *   return await db.query.payouts.findMany();
+ * });
+ *
+ * @example
+ * // With attributes and custom span data
+ * const payouts = await withOtelSpan(
+ *   "api/routes/payouts",
+ *   "fetch payouts",
+ *   async (span) => {
+ *     const results = await db.query.payouts.findMany();
+ *     span.setAttribute("payouts.count", results.length);
+ *     span.addEvent("cache.miss");
+ *     return results;
+ *   },
+ *   { "payouts.limit": 100, "payouts.offset": 0 }
+ * );
+ */
+declare function withOtelSpan<T>(fn: (span: instrumentation_d_exports.Span) => Promise<T>, attributes?: Record<string, string | number | boolean>): Promise<T>;
+//#endregion
+export { withOtelSpan };

package/dist/exports/api/otel.mjs

@@ -0,0 +1 @@
+import{instrumentation_exports as e}from"./packages/appos/src/instrumentation.mjs";import{getCallSites as t}from"node:util";async function n(n,r){let i=t()[1],a=i.scriptName.replace(process.cwd(),``).replace(`file:///`,``),o=i.functionName,s=e.trace.getTracer(a.replace(`build/`,``)).startSpan(o,{attributes:r}),c=e.trace.setSpan(e.context.active(),s);try{let t=await e.context.with(c,()=>n(s));return s.end(),t}catch(e){throw s.recordException(e),s.end(),e}}export{n as withOtelSpan};

package/dist/exports/api/packages/appos/src/constants.mjs

@@ -0,0 +1 @@
+const e=`api`,t=`databases`,n=`workflows`,r=`events`,i=`public`,a=`locales`;export{e as APPOS_DIR,t as DATABASES_DIR,r as EVENTS_DIR,a as LOCALES_DIR,i as PUBLIC_DIR,n as WORKFLOWS_DIR};

package/dist/exports/api/packages/appos/src/instrumentation.d.mts

@@ -0,0 +1,7 @@
+export * from "@opentelemetry/api";
+
+//#region src/instrumentation.d.ts
+
+import * as import__opentelemetry_api from "@opentelemetry/api";
+//#endregion
+export { import__opentelemetry_api as instrumentation_d_exports };

package/dist/exports/api/packages/appos/src/instrumentation.mjs

@@ -0,0 +1 @@
+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};

package/dist/exports/api/packages/appos/src/web/auth.mjs

@@ -0,0 +1 @@
+import"@better-auth/passkey/client";import"@better-auth/sso/client";import"better-auth/client/plugins";import"better-auth/react";const e=`/auth`,t=``;export{e as AUTH_BASE_PATH,t as AUTH_BASE_URL};

package/dist/exports/api/redis.d.mts

@@ -0,0 +1,34 @@
+import { Logger } from "./logger.mjs";
+import { createClient, createCluster } from "redis";
+
+//#region src/api/redis.d.ts
+type RedisClient = ReturnType<typeof createClient> | ReturnType<typeof createCluster>;
+/**
+ * Options for defining a Redis client.
+ */
+interface DefineRedisClientOptions {
+  /**
+   * Logger instance for error reporting.
+   */
+  logger: Logger;
+  /**
+   * Redis URL(s). Single: "redis://localhost:6379", Cluster: comma-separated URLs
+   */
+  url: string;
+}
+/**
+ * Defines Redis client based on URL format with lazy connection.
+ * Single URL → createClient(), comma-separated URLs → createCluster()
+ *
+ * Algorithm:
+ * 1. Split URL by comma to detect cluster vs single
+ * 2. Create appropriate client type
+ * 3. Attach error handler with label for debugging
+ * 4. Wrap in proxy that auto-connects on first use
+ *
+ * @param opts Options for defining the Redis client.
+ * @returns Redis client that auto-connects on first operation.
+ */
+declare function defineRedisClient(opts: DefineRedisClientOptions): RedisClient;
+//#endregion
+export { DefineRedisClientOptions, RedisClient, defineRedisClient };

package/dist/exports/api/redis.mjs

@@ -0,0 +1 @@
+import{createClient as e,createCluster as t}from"redis";function n(n){let r=n.url.split(`,`).map(e=>e.trim()).filter(Boolean),i;i=r.length===1?e({url:r[0]}):t({rootNodes:r.map(e=>({url:e}))}),i.on(`error`,e=>n.logger.error({err:e},`Redis error`));let a=null,o=async()=>{i.isOpen||(a??=i.connect(),await a)};return new Proxy(i,{get(e,t,n){let r=Reflect.get(e,t,n);return typeof r==`function`&&t!==`on`&&t!==`once`?async(...t)=>(await o(),r.apply(e,t)):r}})}export{n as defineRedisClient};