appos 0.2.1-0 → 0.2.2-0

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

@@ -0,0 +1,210 @@
+import { Logger } from "./logger.mjs";
+import { Database } from "./database.mjs";
+import { Auth } from "./auth.mjs";
+import { Cache } from "./cache.mjs";
+import { Config } from "./config.mjs";
+import { EventBus } from "./event.mjs";
+import { Mailer } from "./mailer.mjs";
+import { Storage } from "./storage.mjs";
+import { i18n } from "i18next";
+import { CorsOptions } from "cors";
+import { Options } from "express-rate-limit";
+import { HelmetOptions } from "helmet";
+
+//#region src/api/container.d.ts
+
+/**
+ * Server configuration for the HTTP server.
+ */
+interface ServerConfig {
+  /**
+   * The host address the server will bind to.
+   *
+   * @default "0.0.0.0"
+   */
+  host?: string;
+  /**
+   * The port number the server will listen on.
+   */
+  port: number;
+  /**
+   * Request timeout in milliseconds. Requests exceeding this duration
+   * will receive a 408 Request Timeout response.
+   *
+   * @default 30000
+   */
+  timeout?: number;
+  /**
+   * Maximum request body size for JSON and URL-encoded payloads.
+   * Supports bytes.js format strings (e.g., "1mb", "500kb", "10mb").
+   *
+   * @default "1mb"
+   */
+  bodyLimit?: string;
+  /**
+   * The path for the health check endpoint.
+   *
+   * @default "/health"
+   */
+  healthPath?: string;
+  /**
+   * CORS configuration. Omit or set to undefined to disable.
+   *
+   * @example
+   * cors: { origin: "https://example.com", credentials: true }
+   */
+  cors?: CorsOptions;
+  /**
+   * Security headers configuration (via helmet). Omit or set to undefined to disable.
+   * Recommended for production deployments.
+   *
+   * @example
+   * helmet: { contentSecurityPolicy: false }  // Enable with CSP disabled
+   * helmet: {}  // Enable with all defaults
+   */
+  helmet?: HelmetOptions;
+  /**
+   * Rate limiting configuration. Array of express-rate-limit options.
+   * Each config is applied as a separate middleware - use `skip` function for path-specific limits.
+   * Redis store is automatically configured if `redisUrl` is provided.
+   *
+   * @example
+   * // Global rate limit
+   * rateLimit: [{ windowMs: 60000, limit: 100 }]
+   *
+   * @example
+   * // Path-specific rate limits
+   * rateLimit: [
+   *   { windowMs: 900000, limit: 5, skip: (req) => !req.path.startsWith("/api/auth") },
+   *   { windowMs: 60000, limit: 100 },  // Default for all other routes
+   * ]
+   */
+  rateLimit?: Options[];
+  /**
+   * Redis URL for rate limiting store (for multi-instance deployments).
+   * Server auto-connects and cleans up on shutdown.
+   * If omitted, uses in-memory store (not suitable for production clusters).
+   *
+   * @example
+   * redisUrl: "redis://localhost:6379"
+   */
+  redisUrl?: string;
+}
+/**
+ * Worker configuration for the DBOS workflow worker.
+ */
+interface WorkerConfig {
+  /**
+   * The system database URL for DBOS.
+   */
+  dbUrl: string;
+}
+/**
+ * The base application container type that holds required services like
+ * config, databases, and caches.
+ */
+interface AppContainer<TDb extends Record<"primary", Database> & Record<string, Database> = Record<"primary", Database> & Record<string, Database>> {
+  /**
+   * The application auth configuration.
+   */
+  auth: Auth<TDb>;
+  /**
+   * A map of caches available in the application.
+   */
+  cache: Record<string, Cache>;
+  /**
+   * The application configuration.
+   */
+  config: Config;
+  /**
+   * A map of databases available in the application.
+   */
+  db: TDb;
+  /**
+   * The i18n instance for internationalization.
+   */
+  i18n: i18n;
+  /**
+   * The logger instance for logging messages.
+   */
+  logger: Logger;
+  /**
+   * The event bus for in-memory and Redis pub/sub messaging.
+   */
+  eventBus: EventBus;
+  /**
+   * The mailer instance for sending emails.
+   */
+  mailer: Mailer;
+  /**
+   * Server configuration for the HTTP server.
+   */
+  server: ServerConfig;
+  /**
+   * A map of storage services available in the application.
+   */
+  storage: Record<"primary", Storage> & Record<string, Storage>;
+  /**
+   * Worker configuration for the DBOS workflow worker.
+   */
+  worker: WorkerConfig;
+}
+/**
+ * Global namespace for user container augmentation.
+ * Users can extend Container interface in their container.ts file.
+ */
+declare global {
+  namespace AppOS {
+    interface Container {}
+  }
+}
+/**
+ * The container type used throughout the application.
+ * Merges base AppContainer with user's custom Container augmentations.
+ */
+type Container = AppContainer & AppOS.Container;
+/**
+ * Defines an application container with type-safe validation and inference.
+ *
+ * This helper function ensures that:
+ * 1. All required base fields (config, cache, db) are provided
+ * 2. Custom fields are fully preserved in the inferred type
+ * 3. TypeScript provides autocomplete for all fields in commands/routes
+ *
+ * @template T - The container type extending AppContainer
+ * @param container - The container object with required and custom fields
+ * @returns The same container object with full type inference
+ *
+ * @example
+ * ```typescript
+ * // In your api/main.ts file:
+ * export async function defineContainer() {
+ *   const config = defineConfig(z.object({
+ *     PORT: z.coerce.number().default(3000),
+ *     EVENTS_DB_URL: z.string(),
+ *     WORKER_DB_URL: z.string(),
+ *   }));
+ *   const logger = defineLogger({ level: config.LOG_LEVEL });
+ *
+ *   return defineAppContainer({
+ *     auth: defineAuth({ config }),
+ *     cache: {},
+ *     config,
+ *     db: {},
+ *     eventBus: defineEventBus({ dbUrl: config.EVENTS_DB_URL, logger }),
+ *     i18n: await defineI18n({ ... }),
+ *     logger,
+ *     mailer: defineMailer({ ... }),
+ *     server: {
+ *       port: config.PORT,
+ *     },
+ *     worker: {
+ *       dbUrl: config.WORKER_DB_URL,
+ *     },
+ *   });
+ * }
+ * ```
+ */
+declare function defineAppContainer<T extends AppContainer>(container: T): T;
+//#endregion
+export { AppContainer, Container, ServerConfig, WorkerConfig, defineAppContainer };

package/dist/exports/api/container.mjs

@@ -0,0 +1 @@
+function e(e){return e}export{e as defineAppContainer};

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

@@ -0,0 +1,99 @@
+import { Logger } from "./logger.mjs";
+import * as drizzle_orm22 from "drizzle-orm";
+import { AnyRelations, EmptyRelations } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+import * as drizzle_orm_node_postgres0 from "drizzle-orm/node-postgres";
+import { Pool, PoolConfig } from "pg";
+import { MigrationConfig } from "drizzle-orm/migrator";
+
+//#region src/api/database.d.ts
+/**
+ * Extract qualified table names from db object.
+ */
+type QualifiedTableNames<TDb> = { [K in keyof TDb]: TDb[K] extends {
+  _: {
+    fullSchema: infer S;
+  };
+} ? `${K & string}.${keyof S & string}` : never }[keyof TDb];
+/**
+ * The schema used for migrations.
+ */
+declare const migrationsSchema = "public";
+/**
+ * The type of migration (schema or data).
+ */
+type MigrationType = "schema" | "data";
+/**
+ * Get the migration options for a specific database.
+ *
+ * @param name Name of the database to get migration options for
+ * @param type Type of migration (schema or data), defaults to "schema"
+ * @returns Migration configuration for drizzle-orm
+ */
+declare function defineMigrationOpts(name: string, type?: MigrationType): MigrationConfig;
+/**
+ * Options for defining the database.
+ */
+interface DefineDatabaseOptions<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations> {
+  logger: Logger;
+  poolConfig: PoolConfig;
+  relations?: TRelations;
+  schema?: TSchema;
+}
+/**
+ * The database type.
+ */
+type Database = Awaited<ReturnType<typeof defineDatabase>>;
+/**
+ * Generate old and new row JSONB representations for delete/insert/update queries.
+ * Uses PostgreSQL 18's OLD/NEW support in RETURNING clause.
+ *
+ * @param table The table to generate changes for.
+ * @returns Object containing `_table`, `old` and `new` JSONB columns.
+ */
+declare function dbChanges<T extends PgTable>(table: T): {
+  _table: drizzle_orm22.SQL.Aliased<string>;
+  old: drizzle_orm22.SQL.Aliased<({ [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true ? T["_"]["columns"][Key]["_"]["data"] : T["_"]["columns"][Key]["_"]["data"] | null } extends infer T_1 ? { [K in keyof T_1]: T_1[K] } : never) | null>;
+  new: drizzle_orm22.SQL.Aliased<({ [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true ? T["_"]["columns"][Key]["_"]["data"] : T["_"]["columns"][Key]["_"]["data"] | null } extends infer T_2 ? { [K in keyof T_2]: T_2[K] } : never) | null>;
+};
+/**
+ * Define the database with the provided options.
+ *
+ * Algorithm:
+ * 1. Create a connection pool with sensible defaults
+ * 2. Initialize drizzle ORM with schema and relations
+ *
+ * @param opts The options for defining the database, including pool configuration, relations, and schema.
+ * @template TSchema The schema type for the database.
+ * @template TRelations The relations type for the database.
+ * @returns The defined database instance.
+ */
+declare function defineDatabase<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations>(opts: DefineDatabaseOptions<TSchema, TRelations>): Promise<drizzle_orm_node_postgres0.NodePgDatabase<TSchema, TRelations> & {
+  $client: Pool;
+}>;
+/**
+ * Options for defining a test database.
+ */
+interface DefineTestDatabaseOptions<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations> {
+  connectionString: string;
+  logger: Logger;
+  name: string;
+  schema: TSchema;
+  relations: TRelations;
+}
+/**
+ * Create a single test database with isolated schema.
+ *
+ * @param connectionString - Database connection string
+ * @param name - Name of the test database
+ * @returns Test database instance and cleanup function
+ */
+declare function defineTestDatabase<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations>(opts: DefineTestDatabaseOptions<TSchema, TRelations>): Promise<{
+  cleanUp: () => Promise<void>;
+  db: drizzle_orm_node_postgres0.NodePgDatabase<TSchema, TRelations> & {
+    $client: Pool;
+  };
+  dbName: string;
+}>;
+//#endregion
+export { Database, DefineDatabaseOptions, DefineTestDatabaseOptions, MigrationType, QualifiedTableNames, dbChanges, defineDatabase, defineMigrationOpts, defineTestDatabase, migrationsSchema };

package/dist/exports/api/database.mjs

@@ -0,0 +1 @@
+import{APPOS_DIR as e,DATABASES_DIR as t}from"./packages/appos/src/constants.mjs";import{getTableName as n,sql as r}from"drizzle-orm";import{join as i}from"node:path";import{drizzle as a}from"drizzle-orm/node-postgres";import{migrate as o}from"drizzle-orm/node-postgres/migrator";import{Client as s,Pool as c}from"pg";const l=`public`;function u(n,r=`schema`){let a=r===`schema`?`schema-migrations`:`data-migrations`,o=r===`schema`?`schema-migrations`:`data-migrations`;return{migrationsFolder:`${i(e,t)}/${n}/${a}`,migrationsSchema:l,migrationsTable:o}}var d=class{#e;constructor(e){this.#e=e}logQuery(e,t){this.#e.info(t,e)}};function f(e){let t=n(e);return{_table:r`${r.raw(`'${t}'`)}`.as(`_table`),old:r`to_jsonb(OLD.*)`.as(`old`),new:r`to_jsonb(NEW.*)`.as(`new`)}}async function p(e){return a({client:new c({application_name:`appos`,max:16,...e.poolConfig}),logger:new d(e.logger),relations:e.relations,schema:e.schema})}async function m(e){let t=`test_w${process.env.VITEST_POOL_ID||`0`}_${Date.now()}_${Math.random().toString(36).substring(2,8)}`;await y(e.connectionString,e.name,e.logger);let n=`${e.name}_test_template`,r=_(e.connectionString),i=new s({connectionString:r});await i.connect();try{await i.query(`CREATE DATABASE ${t} WITH TEMPLATE ${n}`)}finally{await i.end()}let o=h(e.connectionString);o.database=t;let l=new c({connectionString:g(o)});return{cleanUp:async()=>{await l.end();let e=new s({connectionString:r});await e.connect();try{await e.query(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1`,[t]),await e.query(`DROP DATABASE IF EXISTS ${t}`)}catch(e){console.error(`Could not drop test database:`,e)}finally{await e.end()}},db:a({client:l,logger:e.logger?new d(e.logger):void 0,relations:e.relations,schema:e.schema}),dbName:t}}function h(e){let t=new URL(e);return{database:t.pathname.slice(1)||`postgres`,host:t.hostname,password:decodeURIComponent(t.password),port:Number.parseInt(t.port||`5432`,10),user:decodeURIComponent(t.username)}}function g(e){let{user:t,password:n,host:r,port:i,database:a}=e;return`postgresql://${encodeURIComponent(t)}:${encodeURIComponent(n)}@${r}:${i}/${a}`}function _(e){let t=h(e);return t.database=`postgres`,g(t)}function v(e){let t=0;for(let n=0;n<e.length;n++){let r=e.charCodeAt(n);t=(t<<5)-t+r,t&=t}return Math.abs(t)}async function y(e,t,n){let r=`${t}_test_template`,i=new s({connectionString:_(e)});await i.connect();let l=v(r);try{if(await i.query(`SELECT pg_advisory_lock($1)`,[l]),(await i.query(`SELECT 1 FROM pg_database WHERE datname = $1`,[r])).rowCount===0){await i.query(`CREATE DATABASE ${r} WITH IS_TEMPLATE = true`);let s=h(e);s.database=r;let l=new c({connectionString:g(s)});try{await o(a({client:l,logger:n?new d(n):void 0}),u(t))}finally{await l.end()}}}finally{await i.query(`SELECT pg_advisory_unlock($1)`,[l]),await i.end()}}export{f as dbChanges,p as defineDatabase,u as defineMigrationOpts,m as defineTestDatabase,l as migrationsSchema};

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

@@ -0,0 +1,235 @@
+import { Logger } from "./logger.mjs";
+import { Container } from "./container.mjs";
+import { z } from "zod";
+
+//#region src/api/event.d.ts
+
+/**
+ * Context available to event handlers.
+ */
+interface EventContext<TInput> {
+  /**
+   * The application container with access to db, mailer, logger, etc.
+   */
+  container: Container;
+  /**
+   * The validated input passed to this event.
+   */
+  input: TInput;
+}
+/**
+ * Options for defining an event bus.
+ */
+interface DefineEventBusOptions {
+  /**
+   * Redis URL for pub/sub.
+   */
+  dbUrl: string;
+  /**
+   * Logger instance for error reporting.
+   */
+  logger: Logger;
+}
+/**
+ * The event bus type for container.
+ */
+type EventBus = ReturnType<typeof defineEventBus>;
+/**
+ * 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
+ */
+declare function defineEventBus(opts: DefineEventBusOptions): {
+  /**
+   * Publish a message to a channel.
+   * Auto-connects on first call if not already connected.
+   *
+   * @param channel - Channel name
+   * @param message - Message payload (will be JSON stringified)
+   */
+  publish(channel: string, message: unknown): Promise<void>;
+  /**
+   * Subscribe to a channel. Returns unsubscribe function.
+   * Uses single connection with callback management.
+   *
+   * @param channel - Channel name
+   * @param callback - Callback for received messages
+   * @returns Unsubscribe function
+   */
+  subscribe(channel: string, callback: (message: unknown) => void): Promise<() => void>;
+  /**
+   * Check if a channel has any subscribers.
+   *
+   * @param channel - Channel name
+   * @returns true if channel has subscribers
+   */
+  hasSubscribers(channel: string): boolean;
+  /**
+   * Close the Redis connections.
+   */
+  close(): Promise<void>;
+};
+/**
+ * Options for defining an event.
+ */
+interface DefineEventOptions<TInput extends z.ZodType> {
+  /**
+   * Zod schema for validating event input.
+   */
+  input: TInput;
+  /**
+   * In-memory handler that runs only on the emitting server.
+   *
+   * @param ctx - Event context with container and input
+   */
+  run: (ctx: EventContext<z.infer<TInput>>) => Promise<void>;
+}
+/**
+ * Event object returned by defineEvent.
+ */
+interface Event<TInput> {
+  /**
+   * The event name (set during registration from filename).
+   */
+  readonly name: string | null;
+  /**
+   * Emit this event with the given input.
+   * Runs in-memory handler, then publishes to Redis (fire-and-forget).
+   *
+   * @param input - Input matching the event's input schema.
+   */
+  emit(input: TInput): Promise<void>;
+  /**
+   * The Zod schema for validating input.
+   */
+  inputSchema: z.ZodType<TInput>;
+  /**
+   * Register this event with the container. Called by the event loader.
+   *
+   * @param container - The application container
+   * @param name - The event name (derived from filename)
+   */
+  register(container: Container, name: string): void;
+  /**
+   * Subscribe to this event via Redis pub/sub.
+   * Use for tRPC subscriptions, SSE, WebSockets.
+   *
+   * @param handler - Handler called when event is emitted on any server
+   * @returns Unsubscribe function to cleanup the subscription
+   */
+  subscribe(handler: (ctx: EventContext<TInput>) => Promise<void>): Promise<() => void>;
+}
+/**
+ * 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();
+ * ```
+ */
+declare function defineEvent<TInput extends z.ZodType>(options: DefineEventOptions<TInput>): Event<z.infer<TInput>>;
+/**
+ * Input schema for dbChangesEvent.
+ */
+declare const dbChangeInputSchema: z.ZodObject<{
+  action: z.ZodEnum<{
+    DELETE: "DELETE";
+    INSERT: "INSERT";
+    UPDATE: "UPDATE";
+  }>;
+  newData: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  oldData: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  organizationId: z.ZodNullable<z.ZodString>;
+  tableName: z.ZodString;
+  timestamp: z.ZodString;
+  userId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Type for dbChangesEvent input.
+ */
+type DbChangeInput = z.infer<typeof dbChangeInputSchema>;
+/**
+ * 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();
+ * ```
+ */
+declare const dbChangesEvent: Event<{
+  action: "DELETE" | "INSERT" | "UPDATE";
+  newData: Record<string, unknown> | null;
+  oldData: Record<string, unknown> | null;
+  organizationId: string | null;
+  tableName: string;
+  timestamp: string;
+  userId: string | null;
+}>;
+/**
+ * Options for loading events.
+ */
+interface LoadEventsOptions {
+  /**
+   * The application container.
+   */
+  container: Container;
+  /**
+   * Optional custom events directory path.
+   */
+  eventsDir?: string;
+}
+/**
+ * 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
+ */
+declare function loadEvents(opts: LoadEventsOptions): Promise<void>;
+//#endregion
+export { DbChangeInput, DefineEventBusOptions, Event, EventBus, EventContext, dbChangeInputSchema, dbChangesEvent, defineEvent, defineEventBus, loadEvents };

package/dist/exports/api/event.mjs

@@ -0,0 +1 @@
+import{defineRedisClient as e}from"./redis.mjs";import{APPOS_DIR as t,EVENTS_DIR as n}from"./packages/appos/src/constants.mjs";import{z as r}from"zod";import{basename as i,join as a}from"node:path";import{glob as o}from"node:fs/promises";import{camelCase as s}from"es-toolkit";function c(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 l(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 u=r.object({action:r.enum([`INSERT`,`UPDATE`,`DELETE`]),newData:r.record(r.string(),r.unknown()).nullable(),oldData:r.record(r.string(),r.unknown()).nullable(),organizationId:r.string().nullable(),tableName:r.string(),timestamp:r.string(),userId:r.string().nullable()}),d=l({input:u,async run(){}});function f(e){return s(i(e,`.ts`))}async function p(e){let{container:r}=e,i=e.eventsDir??a(process.cwd(),t,n);d.register(r,`dbChanges`);let s=await Array.fromAsync(o(`${i}/**/*.ts`,{exclude:[`**/*.test.ts`,`**/*.spec.ts`]}));for(let e of s){let t=await import(e);if(t.default&&typeof t.default==`object`&&`emit`in t.default&&`subscribe`in t.default){let n=f(e);t.default.register(r,n)}}}export{u as dbChangeInputSchema,d as dbChangesEvent,l as defineEvent,c as defineEventBus,p as loadEvents};

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

@@ -0,0 +1,34 @@
+import { InitOptions, i18n, i18n as i18n$1 } from "i18next";
+
+//#region src/api/i18n.d.ts
+
+/**
+ * i18n initialization options extending i18next's InitOptions.
+ * Used for both server and client initialization.
+ */
+interface I18nInitOptions extends InitOptions {}
+/**
+ * Type-safe default options for i18n.
+ * Apps should spread these and override as needed.
+ */
+declare const defaultI18nOptions: {
+  readonly fallbackLng: "en";
+  readonly supportedLngs: readonly ["en"];
+  readonly defaultNS: "translation";
+  readonly ns: readonly ["translation"];
+  readonly interpolation: {
+    readonly escapeValue: false;
+  };
+  readonly react: {
+    readonly 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.
+ */
+declare function defineI18n(opts: I18nInitOptions): Promise<i18n>;
+//#endregion
+export { I18nInitOptions, defaultI18nOptions, defineI18n, type i18n$1 as i18n };

package/dist/exports/api/i18n.mjs

@@ -0,0 +1 @@
+import{LOCALES_DIR as e,PUBLIC_DIR as t}from"./packages/appos/src/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};

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

@@ -0,0 +1,21 @@
+import { DefineLoggerOptions, Logger, defineLogger } from "./logger.mjs";
+import { Database, DefineDatabaseOptions, DefineTestDatabaseOptions, MigrationType, QualifiedTableNames, dbChanges, defineDatabase, defineMigrationOpts, defineTestDatabase, migrationsSchema } from "./database.mjs";
+import { AccessControlRoles, AccessController, AuditAction, Auth, AuthConfig, AuthPasskeyConfig, AuthSessionConfig, DefineAuthOptions, Role, auditActionSchema, createAccessControl, defineAuth } from "./auth.mjs";
+import { Cache, DefineCacheOptions, defineCache } from "./cache.mjs";
+import { Config, baseSchema, defineConfig } from "./config.mjs";
+import { DbChangeInput, DefineEventBusOptions, Event, EventBus, EventContext, dbChangeInputSchema, dbChangesEvent, defineEvent, defineEventBus, loadEvents } from "./event.mjs";
+import { DefineMailerOptions, Mailer, MailerPayload, MailerPayloadHtml, MailerPayloadReact, defineMailer } from "./mailer.mjs";
+import { NewStorageAttachment, NewStorageBlob, NewStorageVariantRecord, StorageAttachment, StorageBlob, StorageRelations, StorageRelationsConfig, StorageTables, StorageVariantRecord, defineStorageSchema } from "./storage-schema.mjs";
+import { ScheduledWorkflowContext, WorkflowContext, WorkflowHandle, defineScheduledWorkflow, defineWorkflow, loadWorkflows } from "./workflow.mjs";
+import { ImageTransformations, ResizeOptions, resizeSchema, transformationsSchema } from "./workflows/generate-image-variant.mjs";
+import { DatabaseWithStorage, DefineS3DiskOptions, DefineStorageOptions, Storage, StorageService, defineS3Disk, defineStorage } from "./storage.mjs";
+import { AppContainer, Container, ServerConfig, WorkerConfig, defineAppContainer } from "./container.mjs";
+import { AppContext, DefineAppContextOpts, SessionData, defineAppContext } from "./app-context.mjs";
+import { defineAuthSchema } from "./auth-schema.mjs";
+import { I18nInitOptions, defaultI18nOptions, defineI18n, i18n } from "./i18n.mjs";
+import { Middleware, defineMiddleware, loadMiddleware } from "./middleware.mjs";
+import { DefineOpenAPIConfig, DefineOpenAPIConfigInput, DefineOpenAPIReturn, HandlerParams, OpenAPIMethodSpec, OpenAPIObjectConfigV31, OpenAPIRegistration, RouteModule, ValidationErrorResponse, appDir, defineOpenAPI, defineOpenAPIConfig, defineOpenAPIEndpoint, defineTypedResponses, generateOpenAPIDocument, loadAndRegisterAPIRoutes, registerRoutes, scanAPIRoutes, writeOpenAPISpecs } from "./openapi.mjs";
+import { withOtelSpan } from "./otel.mjs";
+import { DefineRedisClientOptions, RedisClient, defineRedisClient } from "./redis.mjs";
+import { CustomTypeOptions } from "i18next";
+export { AccessControlRoles, AccessController, AppContainer, AppContext, AuditAction, Auth, AuthConfig, AuthPasskeyConfig, AuthSessionConfig, Cache, Config, Container, type CustomTypeOptions, Database, DatabaseWithStorage, DbChangeInput, DefineAppContextOpts, DefineAuthOptions, DefineCacheOptions, DefineDatabaseOptions, DefineEventBusOptions, DefineLoggerOptions, DefineMailerOptions, DefineOpenAPIConfig, DefineOpenAPIConfigInput, DefineOpenAPIReturn, DefineRedisClientOptions, DefineS3DiskOptions, DefineStorageOptions, DefineTestDatabaseOptions, Event, EventBus, EventContext, HandlerParams, I18nInitOptions, ImageTransformations, Logger, Mailer, MailerPayload, MailerPayloadHtml, MailerPayloadReact, Middleware, MigrationType, NewStorageAttachment, NewStorageBlob, NewStorageVariantRecord, OpenAPIMethodSpec, OpenAPIObjectConfigV31, OpenAPIRegistration, QualifiedTableNames, RedisClient, ResizeOptions, Role, RouteModule, ScheduledWorkflowContext, ServerConfig, SessionData, Storage, StorageAttachment, StorageBlob, StorageRelations, StorageRelationsConfig, StorageService, StorageTables, StorageVariantRecord, ValidationErrorResponse, WorkerConfig, WorkflowContext, WorkflowHandle, appDir, 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, i18n, loadAndRegisterAPIRoutes, loadEvents, loadMiddleware, loadWorkflows, migrationsSchema, registerRoutes, resizeSchema, scanAPIRoutes, transformationsSchema, withOtelSpan, writeOpenAPISpecs };

package/dist/exports/api/index.mjs

@@ -0,0 +1 @@
+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{appDir as E,defineOpenAPI as D,defineOpenAPIConfig as O,defineOpenAPIEndpoint as k,defineTypedResponses as A,generateOpenAPIDocument as j,loadAndRegisterAPIRoutes as M,registerRoutes as N,scanAPIRoutes as P,writeOpenAPISpecs as F}from"./openapi.mjs";import{withOtelSpan as I}from"./otel.mjs";import{defineScheduledWorkflow as L,defineWorkflow as R,loadWorkflows as z}from"./workflow.mjs";import{resizeSchema as B,transformationsSchema as V}from"./workflows/generate-image-variant.mjs";import{StorageService as H,defineS3Disk as U,defineStorage as W}from"./storage.mjs";import{defineStorageSchema as G}from"./storage-schema.mjs";export{H as StorageService,E as appDir,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,D as defineOpenAPI,O as defineOpenAPIConfig,k as defineOpenAPIEndpoint,a as defineRedisClient,U as defineS3Disk,L as defineScheduledWorkflow,W as defineStorage,G as defineStorageSchema,p as defineTestDatabase,A as defineTypedResponses,R as defineWorkflow,j as generateOpenAPIDocument,M as loadAndRegisterAPIRoutes,y as loadEvents,T as loadMiddleware,z as loadWorkflows,m as migrationsSchema,N as registerRoutes,B as resizeSchema,P as scanAPIRoutes,V as transformationsSchema,I as withOtelSpan,F as writeOpenAPISpecs};

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

@@ -0,0 +1,21 @@
+import pino, { LoggerOptions } from "pino";
+
+//#region src/api/logger.d.ts
+
+/**
+ * Extended logger options with OpenTelemetry support.
+ */
+interface DefineLoggerOptions extends LoggerOptions {}
+/**
+ * The logger instance type.
+ */
+type Logger = Awaited<ReturnType<typeof defineLogger>>;
+/**
+ * Define the logger instance.
+ *
+ * @param opts - The options.
+ * @returns The logger.
+ */
+declare function defineLogger(opts: DefineLoggerOptions): Promise<pino.Logger<never, boolean>>;
+//#endregion
+export { DefineLoggerOptions, Logger, defineLogger };

package/dist/exports/api/logger.mjs

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