@kuckit/sdk 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,638 +1,17 @@
-import { InjectionMode, asClass, asClass as asClass$1, asFunction, asFunction as asFunction$1, asValue, asValue as asValue$1, createContainer } from "awilix";
+import { t as registerCoreModule } from "./core.module-Ctm2stcL.js";
+import { n as disposeContainer, t as createKuckitContainer } from "./container-D0DK003A.js";
+import { t as defineKuckitModule } from "./define-module-B83hUzJz.js";
+import { i as resetModuleRegistry, n as getModuleRegistry, r as getModulesWithCapability, t as ModuleRegistry } from "./registry-CL_5erME.js";
+import { n as getSchemaRegistry, r as resetSchemaRegistry, t as SchemaRegistry } from "./registry-BPYpBtYx.js";
+import "./schema-BuA2HF_H.js";
+import { n as loadKuckitModules, t as createModuleShutdownHandler } from "./loader-Ct4ZivZz.js";
+import "./modules-BDQBjAbp.js";
+import { t as defineConfig } from "./define-config-GYI_W9K6.js";
+import { i as tryLoadKuckitConfig, n as hasUnifiedConfig, r as loadKuckitConfig, t as findConfigFile } from "./loader-lCPWCMYx.js";
+import "./config-BeiJJZGf.js";
+import { asClass, asFunction, asValue } from "awilix";
 import * as Domain from "@kuckit/domain";
-import { SystemClock } from "@kuckit/domain";
-import { google } from "@ai-sdk/google";
-import { auth } from "@kuckit/auth";
-import { InMemoryCacheStore, InMemoryEventBus, InMemoryRateLimiterStore, createDb, createDbPool, makeErrorHandler, makeRequestLogger, makeStructuredLogger } from "@kuckit/infrastructure";
-import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
 import * as Application from "@kuckit/application";
 import * as Contracts from "@kuckit/contracts";
 
-//#region src/core/core.module.ts
-/**
-* Register core infrastructure services into the container
-*
-* This registers:
-* - Database pool and connection
-* - Clock
-* - Logger (structured, Loki/Prometheus compatible)
-* - AI provider
-* - Auth
-* - Event bus
-* - Cache store
-* - Rate limiter store
-* - Request-scoped logger
-*/
-const registerCoreModule = (container) => {
-	container.register({
-		dbPool: asFunction$1(({ config }) => createDbPool(config.databaseUrl)).singleton(),
-		db: asFunction$1(({ dbPool }) => createDb(dbPool)).singleton(),
-		clock: asValue$1(new SystemClock()),
-		logger: asFunction$1(({ config }) => makeStructuredLogger({
-			enableFile: config.enableFileLogging,
-			logDir: config.logDir,
-			minLevel: config.logLevel
-		})).singleton(),
-		errorHandler: asFunction$1(({ logger }) => makeErrorHandler(logger)).singleton(),
-		auth: asValue$1(auth),
-		aiProvider: asFunction$1(() => google("gemini-2.5-flash")).singleton(),
-		eventBus: asFunction$1(({ logger }) => new InMemoryEventBus(logger)).singleton(),
-		cacheStore: asClass$1(InMemoryCacheStore).singleton(),
-		rateLimiterStore: asClass$1(InMemoryRateLimiterStore).singleton(),
-		requestLogger: asFunction$1(({ logger, requestId, session }) => makeRequestLogger({
-			requestId,
-			userId: session?.user?.id,
-			baseLogger: logger
-		})).scoped()
-	});
-};
-
-//#endregion
-//#region src/core/container.ts
-/**
-* Factory function to create a Kuckit DI container
-*
-* This is the primary entry point for applications using the SDK.
-* It creates an Awilix container with core infrastructure services pre-registered.
-*
-* @example
-* ```ts
-* const container = await createKuckitContainer({
-*   config: {
-*     databaseUrl: process.env.DATABASE_URL!,
-*     enableFileLogging: true,
-*     logDir: './logs',
-*     logLevel: 'INFO',
-*     env: 'production',
-*   },
-*   extraRegistrations: (container) => {
-*     // Register your custom services
-*     container.register({
-*       myService: asClass(MyService).singleton(),
-*     })
-*   },
-* })
-* ```
-*/
-const createKuckitContainer = async (opts) => {
-	const container = createContainer({ injectionMode: InjectionMode.PROXY });
-	container.register({ config: asValue$1(opts.config) });
-	registerCoreModule(container);
-	if (opts.extraRegistrations) await opts.extraRegistrations(container);
-	return container;
-};
-/**
-* Cleanup container resources gracefully
-*
-* Call this when shutting down your application to close database connections
-* and other resources.
-*/
-const disposeContainer = async (container) => {
-	const { dbPool } = container.cradle;
-	if (dbPool && typeof dbPool === "object" && "end" in dbPool && typeof dbPool.end === "function") await dbPool.end();
-};
-
-//#endregion
-//#region src/modules/define-module.ts
-/**
-* Helper to define a Kuckit module with type safety
-*
-* This is the primary way to create a module for the Kuckit SDK.
-* It provides type inference for the configuration and validates
-* the module structure at compile time.
-*
-* @example
-* ```ts
-* // In your module's main file (e.g., src/module.ts)
-* import { defineKuckitModule, asClass, asFunction } from '@kuckit/sdk'
-*
-* interface BillingModuleConfig {
-*   currency: string
-*   taxRate: number
-* }
-*
-* export const kuckitModule = defineKuckitModule<BillingModuleConfig>({
-*   id: 'acme.billing',
-*   displayName: 'Billing',
-*   description: 'Invoice and payment processing',
-*   version: '1.0.0',
-*
-*   register(ctx) {
-*     ctx.container.register({
-*       invoiceRepository: asClass(DrizzleInvoiceRepository).scoped(),
-*       paymentService: asFunction(makePaymentService).singleton(),
-*     })
-*   },
-*
-*   registerApi(ctx) {
-*     ctx.addApiRegistration({
-*       type: 'rpc-router',
-*       name: 'billing',
-*       router: createBillingRouter(ctx.container),
-*     })
-*   },
-*
-*   onBootstrap(ctx) {
-*     const logger = ctx.container.resolve('logger')
-*     logger.info(`Billing module initialized with currency: ${ctx.config.currency}`)
-*   },
-* })
-* ```
-*
-* @param mod - The module definition object
-* @returns The same module definition (for type inference)
-*/
-const defineKuckitModule = (mod) => {
-	if (!mod.id) throw new Error("Module must have an id");
-	if (typeof mod.id !== "string" || mod.id.trim() === "") throw new Error("Module id must be a non-empty string");
-	return mod;
-};
-
-//#endregion
-//#region src/modules/registry.ts
-/**
-* Validates that a capability string matches expected patterns
-*/
-const isValidCapability = (cap) => {
-	if ([
-		"nav.item",
-		"settings.page",
-		"dashboard.widget",
-		"api.webhook",
-		"api.public",
-		"slot.provider"
-	].includes(cap)) return true;
-	if (cap.startsWith("custom.") && cap.length > 7) return true;
-	return false;
-};
-/**
-* Registry for loaded Kuckit modules
-*
-* Tracks all loaded modules and their capabilities for querying.
-*/
-var ModuleRegistry = class {
-	modules = /* @__PURE__ */ new Map();
-	frozen = false;
-	/**
-	* Register a loaded module
-	* @throws Error if registry is frozen or module ID already exists
-	*/
-	register(module) {
-		if (this.frozen) throw new Error(`ModuleRegistry is frozen. Cannot register module "${module.id}" after finalization.`);
-		if (this.modules.has(module.id)) throw new Error(`Module with ID "${module.id}" is already registered.`);
-		const capabilities = module.capabilities ?? [];
-		for (const cap of capabilities) if (!isValidCapability(cap)) throw new Error(`Invalid capability "${cap}" in module "${module.id}". Capabilities must be built-in (nav.item, settings.page, etc.) or custom.* prefixed.`);
-		this.modules.set(module.id, {
-			id: module.id,
-			displayName: module.displayName,
-			description: module.description,
-			version: module.version,
-			capabilities
-		});
-	}
-	/**
-	* Get all registered modules
-	*/
-	getAll() {
-		return Array.from(this.modules.values());
-	}
-	/**
-	* Get a module by ID
-	*/
-	getById(id) {
-		return this.modules.get(id);
-	}
-	/**
-	* Check if a module is registered
-	*/
-	has(id) {
-		return this.modules.has(id);
-	}
-	/**
-	* Get all modules that have a specific capability
-	*/
-	getWithCapability(capability) {
-		return this.getAll().filter((mod) => mod.capabilities.includes(capability));
-	}
-	/**
-	* Check if a specific module has a capability
-	*/
-	hasCapability(moduleId, capability) {
-		const module = this.modules.get(moduleId);
-		return module ? module.capabilities.includes(capability) : false;
-	}
-	/**
-	* Get all unique capabilities across all modules
-	*/
-	getAllCapabilities() {
-		const caps = /* @__PURE__ */ new Set();
-		for (const mod of this.modules.values()) for (const cap of mod.capabilities) caps.add(cap);
-		return Array.from(caps);
-	}
-	/**
-	* Freeze the registry to prevent further modifications
-	*/
-	freeze() {
-		this.frozen = true;
-	}
-	/**
-	* Check if registry is frozen
-	*/
-	isFrozen() {
-		return this.frozen;
-	}
-	/**
-	* Get the number of registered modules
-	*/
-	get size() {
-		return this.modules.size;
-	}
-	/**
-	* Clear all modules (only works if not frozen)
-	*/
-	clear() {
-		if (this.frozen) throw new Error("ModuleRegistry is frozen. Cannot clear modules.");
-		this.modules.clear();
-	}
-};
-let globalRegistry = null;
-/**
-* Get the global module registry
-* Creates one if it doesn't exist
-*/
-function getModuleRegistry() {
-	if (!globalRegistry) globalRegistry = new ModuleRegistry();
-	return globalRegistry;
-}
-/**
-* Get all modules that have a specific capability
-* Convenience function that uses the global registry
-*/
-function getModulesWithCapability(capability) {
-	return getModuleRegistry().getWithCapability(capability);
-}
-/**
-* Reset the global registry (mainly for testing)
-*/
-function resetModuleRegistry() {
-	globalRegistry = null;
-}
-
-//#endregion
-//#region src/schema/registry.ts
-/**
-* Registry for module-owned database schemas
-*
-* Allows modules to register their Drizzle schemas during the register() hook.
-* The CLI uses this registry to aggregate schemas for drizzle-kit operations.
-*/
-var SchemaRegistry = class {
-	schemas = /* @__PURE__ */ new Map();
-	/**
-	* Register a schema from a module
-	* @param moduleId - Module identifier (e.g., 'acme.billing')
-	* @param tableName - Table name identifier (e.g., 'invoices')
-	* @param schema - Drizzle PgTable schema
-	*/
-	register(moduleId, tableName, schema) {
-		const key = `${moduleId}:${tableName}`;
-		if (this.schemas.has(key)) throw new Error(`Schema "${tableName}" already registered by module "${moduleId}"`);
-		this.schemas.set(key, {
-			moduleId,
-			tableName,
-			schema
-		});
-	}
-	/**
-	* Get all registered schemas
-	*/
-	getAll() {
-		return new Map(this.schemas);
-	}
-	/**
-	* Get schemas registered by a specific module
-	*/
-	getByModule(moduleId) {
-		return Array.from(this.schemas.values()).filter((entry) => entry.moduleId === moduleId);
-	}
-	/**
-	* Get all schemas as a flat object for drizzle-kit
-	* Keys are table names, values are PgTable schemas
-	*/
-	getAllSchemas() {
-		const result = {};
-		for (const entry of this.schemas.values()) result[entry.tableName] = entry.schema;
-		return result;
-	}
-	/**
-	* Check if any schemas are registered
-	*/
-	hasSchemas() {
-		return this.schemas.size > 0;
-	}
-	/**
-	* Get the count of registered schemas
-	*/
-	get size() {
-		return this.schemas.size;
-	}
-	/**
-	* Clear all schemas (mainly for testing)
-	*/
-	clear() {
-		this.schemas.clear();
-	}
-};
-let globalSchemaRegistry = null;
-/**
-* Get the global schema registry
-* Creates one if it doesn't exist
-*/
-function getSchemaRegistry() {
-	if (!globalSchemaRegistry) globalSchemaRegistry = new SchemaRegistry();
-	return globalSchemaRegistry;
-}
-/**
-* Reset the global schema registry (mainly for testing)
-*/
-function resetSchemaRegistry() {
-	globalSchemaRegistry = null;
-}
-
-//#endregion
-//#region src/modules/loader.ts
-/**
-* Validates that a module has the correct shape
-*/
-const validateModule = (candidate, packageName) => {
-	if (!candidate || typeof candidate !== "object") throw new Error(`Invalid Kuckit module from "${packageName}": expected an object with module definition`);
-	const mod = candidate;
-	if (!mod.id || typeof mod.id !== "string") throw new Error(`Invalid Kuckit module from "${packageName}": missing or invalid 'id' property`);
-	for (const hookName of [
-		"register",
-		"registerApi",
-		"onBootstrap",
-		"onShutdown"
-	]) if (mod[hookName] !== void 0 && typeof mod[hookName] !== "function") throw new Error(`Invalid Kuckit module from "${packageName}": '${hookName}' must be a function`);
-	return mod;
-};
-/**
-* Load and initialize Kuckit modules
-*
-* This function orchestrates the module loading lifecycle:
-*
-* 1. **Import Phase**: Dynamic import each module package
-* 2. **Register Phase**: Run register() hooks (DI bindings)
-* 3. **API Phase**: Run registerApi() hooks (API routes)
-* 4. **Wire Phase**: Call onApiRegistrations callback
-* 5. **Bootstrap Phase**: Run onBootstrap() hooks
-* 6. **Complete Phase**: Call onComplete callback
-*
-* @example
-* ```ts
-* await loadKuckitModules({
-*   container,
-*   env: 'production',
-*   modules: [
-*     { package: '@kuckit/users-module' },
-*     { package: '@acme/billing-module', config: { currency: 'USD' } },
-*     { package: './src/modules/custom', disabled: process.env.DISABLE_CUSTOM === 'true' },
-*   ],
-*   onApiRegistrations: (registrations) => {
-*     // Wire up oRPC routers, REST routes, etc.
-*     for (const reg of registrations) {
-*       if (reg.type === 'rpc-router') {
-*         rootRouter.merge(reg.name, reg.router)
-*       }
-*     }
-*   },
-*   onComplete: () => {
-*     console.log('All modules loaded!')
-*   },
-* })
-* ```
-*/
-const loadKuckitModules = async (opts) => {
-	const { container, env, modules, onApiRegistrations, onComplete } = opts;
-	const apiRegistrations = [];
-	const loadedModules = [];
-	const registry = getModuleRegistry();
-	for (const spec of modules) {
-		if (spec.disabled) continue;
-		let validated;
-		if (spec.module) validated = validateModule(spec.module, spec.module.id ?? "direct-module");
-		else if (spec.package) {
-			let imported;
-			try {
-				imported = await import(spec.package);
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`Failed to import module "${spec.package}": ${message}`);
-			}
-			validated = validateModule(imported.kuckitModule ?? imported.default, spec.package);
-		} else throw new Error("ModuleSpec must have either \"module\" or \"package\" property");
-		registry.register(validated);
-		loadedModules.push({
-			...validated,
-			_config: spec.config
-		});
-	}
-	for (const mod of loadedModules) if (mod.register) {
-		const schemaRegistry = getSchemaRegistry();
-		const ctx = {
-			container,
-			env,
-			config: mod._config ?? {},
-			registerSchema: (tableName, schema) => {
-				schemaRegistry.register(mod.id, tableName, schema);
-			}
-		};
-		try {
-			await mod.register(ctx);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			throw new Error(`Module "${mod.id}" register() failed: ${message}`);
-		}
-	}
-	for (const mod of loadedModules) if (mod.registerApi) {
-		const schemaRegistry = getSchemaRegistry();
-		const ctx = {
-			container,
-			env,
-			config: mod._config ?? {},
-			registerSchema: (tableName, schema) => {
-				schemaRegistry.register(mod.id, tableName, schema);
-			},
-			addApiRegistration: (reg) => {
-				apiRegistrations.push(reg);
-			}
-		};
-		try {
-			await mod.registerApi(ctx);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			throw new Error(`Module "${mod.id}" registerApi() failed: ${message}`);
-		}
-	}
-	if (onApiRegistrations && apiRegistrations.length > 0) await onApiRegistrations(apiRegistrations);
-	for (const mod of loadedModules) if (mod.onBootstrap) {
-		const schemaRegistry = getSchemaRegistry();
-		const ctx = {
-			container,
-			env,
-			config: mod._config ?? {},
-			registerSchema: (tableName, schema) => {
-				schemaRegistry.register(mod.id, tableName, schema);
-			}
-		};
-		try {
-			await mod.onBootstrap(ctx);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			throw new Error(`Module "${mod.id}" onBootstrap() failed: ${message}`);
-		}
-	}
-	if (onComplete) await onComplete();
-};
-/**
-* Create a shutdown handler for loaded modules
-*
-* Returns a function that calls onShutdown() on all modules in reverse order.
-* Call this during graceful shutdown.
-*
-* @example
-* ```ts
-* const shutdown = createModuleShutdownHandler(loadedModules, container, env)
-*
-* process.on('SIGTERM', async () => {
-*   await shutdown()
-*   process.exit(0)
-* })
-* ```
-*/
-const createModuleShutdownHandler = (modules, container, env) => {
-	return async () => {
-		for (const mod of [...modules].reverse()) if (mod.onShutdown) {
-			const schemaRegistry = getSchemaRegistry();
-			const ctx = {
-				container,
-				env,
-				config: {},
-				registerSchema: (tableName, schema) => {
-					schemaRegistry.register(mod.id, tableName, schema);
-				}
-			};
-			try {
-				await mod.onShutdown(ctx);
-			} catch (error) {
-				console.error(`Module "${mod.id}" onShutdown() failed:`, error);
-			}
-		}
-	};
-};
-
-//#endregion
-//#region src/config/define-config.ts
-/**
-* Define a Kuckit configuration with full type safety.
-*
-* This helper provides IntelliSense support and type checking for your configuration.
-*
-* @example
-* ```typescript
-* // kuckit.config.ts
-* import { defineConfig } from '@kuckit/sdk'
-*
-* export default defineConfig({
-*   modules: [
-*     { package: '@kuckit/users-module' },
-*     { package: '@acme/billing-module', config: { currency: 'USD' } },
-*   ],
-*
-*   server: {
-*     apiPrefix: '/api',
-*   },
-*
-*   client: {
-*     routeInjection: true,
-*   },
-* })
-* ```
-*/
-function defineConfig(config) {
-	return config;
-}
-
-//#endregion
-//#region src/config/loader.ts
-const CONFIG_FILES = [
-	"kuckit.config.ts",
-	"kuckit.config.js",
-	"kuckit.config.mjs"
-];
-/**
-* Find the config file path by searching from cwd upward
-*/
-function findConfigFile(cwd = process.cwd()) {
-	let dir = cwd;
-	while (dir !== dirname(dir)) {
-		for (const file of CONFIG_FILES) {
-			const configPath = resolve(dir, file);
-			if (existsSync(configPath)) return configPath;
-		}
-		dir = dirname(dir);
-	}
-	for (const file of CONFIG_FILES) {
-		const configPath = resolve(dir, file);
-		if (existsSync(configPath)) return configPath;
-	}
-	return null;
-}
-/**
-* Check if a unified config file exists
-*/
-function hasUnifiedConfig(cwd = process.cwd()) {
-	return findConfigFile(cwd) !== null;
-}
-/**
-* Load Kuckit configuration from file
-*
-* Uses jiti for TypeScript support at runtime.
-* Falls back to dynamic import for JS/MJS files.
-*
-* @param cwd - Directory to start searching from (default: process.cwd())
-* @throws Error if config file not found or invalid
-*/
-async function loadKuckitConfig(cwd = process.cwd()) {
-	const configPath = findConfigFile(cwd);
-	if (!configPath) throw new Error(`No Kuckit config file found. Create a kuckit.config.ts at your project root.\nSearched from: ${cwd}`);
-	let config;
-	if (configPath.endsWith(".ts")) {
-		const { createJiti } = await import("jiti");
-		const loaded = await createJiti(cwd, { interopDefault: true }).import(configPath);
-		config = loaded.default ?? loaded;
-	} else {
-		const loaded = await import(configPath);
-		config = loaded.default ?? loaded;
-	}
-	if (!config || typeof config !== "object") throw new Error(`Invalid Kuckit config at ${configPath}: expected an object`);
-	if (!Array.isArray(config.modules)) throw new Error(`Invalid Kuckit config at ${configPath}: 'modules' must be an array`);
-	return {
-		...config,
-		_configPath: configPath
-	};
-}
-/**
-* Try to load config, returning null if not found
-*/
-async function tryLoadKuckitConfig(cwd = process.cwd()) {
-	try {
-		return await loadKuckitConfig(cwd);
-	} catch {
-		return null;
-	}
-}
-
-//#endregion
 export { Application, Contracts, Domain, ModuleRegistry, SchemaRegistry, asClass, asFunction, asValue, createKuckitContainer, createModuleShutdownHandler, defineConfig, defineKuckitModule, disposeContainer, findConfigFile, getModuleRegistry, getModulesWithCapability, getSchemaRegistry, hasUnifiedConfig, loadKuckitConfig, loadKuckitModules, registerCoreModule, resetModuleRegistry, resetSchemaRegistry, tryLoadKuckitConfig };