@happyvertical/smrt-tenancy 0.30.0

package/AGENTS.md

@@ -0,0 +1,71 @@
+# @happyvertical/smrt-tenancy
+
+Multi-tenancy via AsyncLocalStorage context propagation with automatic query filtering and tenant ID population.
+
+## Context Propagation
+
+```typescript
+import { withTenant, getTenantId, withSystemContext } from '@happyvertical/smrt-tenancy';
+
+await withTenant({ tenantId: 'tenant-123' }, async () => {
+  // All SmrtCollection queries auto-filtered by tenantId
+  // All creates auto-populate tenantId
+  const docs = await collection.list({}); // WHERE tenant_id = 'tenant-123'
+});
+
+await withSystemContext(async () => { /* bypasses all tenant checks */ });
+```
+
+**Critical distinction**: `withSystemContext()` sets a SYSTEM_CONTEXT_MARKER sentinel — different from "no context" (undefined). Interceptor can distinguish intentional bypass from missing context.
+
+## Interceptor System
+
+Hooks into SmrtCollection via `GlobalInterceptors.register()` (priority 100, runs first):
+
+| Hook | Behavior |
+|------|----------|
+| `beforeList` | Injects `tenantId` into WHERE clause; validates existing filters match context |
+| `beforeGet` | Same — converts ID lookup to `{ id, tenantId }` |
+| `beforeSave` | Auto-populates tenantId if empty + `autoPopulate: true`; validates if already set |
+| `beforeDelete` | Validates instance.tenantId matches context |
+| `beforeQuery` | Enforces raw SQL policy on tenant-scoped classes (`throw`/`warn`/`allow`) |
+| `afterSave` | Emits `directory.<class>.created`/`updated` via `dispatchBus` for configured `directoryClasses` |
+| `afterDelete` | Emits `directory.<class>.deleted` via `dispatchBus` for configured `directoryClasses` |
+
+Mismatches throw `TenantIsolationError`. Missing required context throws `TenantContextError`.
+
+## Registration — Two Patterns
+
+```typescript
+// Pattern 1: Tenancy decorator
+@TenantScoped({ mode: 'optional' })
+class Doc extends SmrtObject { @tenantId({ nullable: true }) tenantId: string | null = null; }
+
+// Pattern 2: Core decorator (tenancy package reads this too)
+@smrt({ tenantScoped: { mode: 'optional' } })
+class Doc extends SmrtObject { tenantId: string | null = null; }
+```
+
+Modes: `'required'` (default — throws without context) or `'optional'` (passes through if no context).
+
+## Adapters
+
+- **Express**: `createExpressMiddleware()` — uses `enterTenantContext()` (not withTenant, because middleware returns before handlers run)
+- **SvelteKit**: `createSvelteKitHandle()` — stores context in `event.locals`
+- **CLI**: `createCliContext()` — `run()`, `runWithTenant()`, `runAsSystem()`, `runAsSuperAdmin()`
+
+## Super Admin Bypass
+
+`withSuperAdminBypass()` keeps tenant context but disables auto-filtering. Different from `withSystemContext()` which removes context entirely.
+
+## Gotchas
+
+- **Context lost in callbacks**: `setTimeout(() => getTenantId(), 100)` → undefined. Fix: `TenantContext.bind(fn)`
+- **Nested contexts override**: inner `withTenant()` overrides outer; restores on exit
+- **Auto-populate only if empty**: if tenantId already set, interceptor validates (not overwrites)
+- **Isolation checked at query time**: `list({ where: { tenantId: 'other' } })` throws immediately
+- **Testing**: `resetTenancy()` + `setupTestTenancy()` in beforeEach; `testTenantIsolation()` helper
+
+## Known exceptions to monorepo standards
+
+- **`serializeInstance()` in `src/interceptor.ts` calls `instance.toJSON()` directly** (standards.md §7 forbids this in favor of `transformJSON()`). The interceptor must serialize arbitrary instances handed to it — including workspace stubs and plain-object test doubles whose classes may not extend `SmrtObject` and therefore have no `transformJSON()` hook. The call is duck-typed and falls back to manual key iteration when `toJSON` is absent. See the inline comment at the call site for the full rationale.

package/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2025> <Happy Vertical Corporation>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# @happyvertical/smrt-tenancy
+
+Multi-tenancy for SMRT with AsyncLocalStorage context propagation, automatic query filtering, and tenant ID population.
+
+## Installation
+
+```bash
+pnpm install @happyvertical/smrt-tenancy
+```
+
+## Usage
+
+```typescript
+import { enableTenancy, TenantScoped, tenantId, withTenant } from '@happyvertical/smrt-tenancy';
+import { smrt, SmrtObject } from '@happyvertical/smrt-core';
+
+// 1. Enable tenancy globally (once at app startup)
+enableTenancy();
+
+// 2. Mark classes as tenant-scoped
+@smrt()
+@TenantScoped({ mode: 'optional' })
+class Document extends SmrtObject {
+  @tenantId({ nullable: true })
+  tenantId: string | null = null;
+
+  title: string = '';
+}
+
+// 3. Wrap operations in tenant context
+await withTenant({ tenantId: 'tenant-123' }, async () => {
+  const docs = await collection.list({ where: { status: 'active' } });
+  // Executes: WHERE tenant_id = 'tenant-123' AND status = 'active'
+});
+```
+
+## API
+
+### Decorators
+
+| Export | Description |
+|--------|-------------|
+| `TenantScoped(options?)` | Class decorator. Modes: `'required'` (default) or `'optional'` |
+| `tenantId(options?)` | Property decorator for the tenant ID field |
+
+### Context Runners
+
+| Export | Description |
+|--------|-------------|
+| `withTenant(ctx, fn)` | Run code scoped to a tenant |
+| `withTenantSync(ctx, fn)` | Synchronous variant |
+| `withSystemContext(fn)` | Bypass all tenant checks (admin/migrations) |
+| `withSuperAdminBypass(fn)` | Keep tenant context but disable auto-filtering |
+| `enterTenantContext(ctx)` | Enter context without callback (for middleware) |
+
+### Context Accessors
+
+| Export | Description |
+|--------|-------------|
+| `getCurrentTenant()` | Get current tenant context (may be undefined) |
+| `getTenantId()` | Get tenant ID string (may be undefined) |
+| `requireTenant()` | Get tenant context or throw |
+| `requireTenantId()` | Get tenant ID or throw |
+| `hasTenantContext()` | Check if in tenant context |
+| `isSystemContext()` | Check if in system context |
+| `isSuperAdminBypass()` | Check if super admin bypass is active |
+| `TenantContext` | AsyncLocalStorage instance (advanced use) |
+
+### Errors
+
+`TenantContextError` (missing required context), `TenantIsolationError` (tenant mismatch).
+
+### Interceptor
+
+| Export | Description |
+|--------|-------------|
+| `enableTenancy()` | Register tenant interceptor globally |
+| `disableTenancy()` | Remove tenant interceptor |
+| `isTenancyEnabled()` | Check if tenancy is active |
+| `createTenantInterceptor(options?)` | Create interceptor manually |
+
+### Framework Adapters
+
+| Export | Description |
+|--------|-------------|
+| `createSvelteKitHandle(options)` | SvelteKit hooks.server.ts handler |
+| `createExpressMiddleware(options)` | Express middleware |
+| `createCliContext(options)` | CLI context with `run()`, `runWithTenant()`, `runAsSystem()` |
+
+### Registry (Advanced)
+
+| Export | Description |
+|--------|-------------|
+| `isTenantScopedClass(name)` | Check if a class is tenant-scoped |
+| `getTenantScopedConfig(name)` | Get tenant config for a class |
+| `getAllTenantScopedClasses()` | List all registered tenant-scoped classes |
+| `registerTenantScopedClass()` | Register a class programmatically |
+| `unregisterTenantScopedClass()` | Remove a class from registry |
+| `clearTenantScopedRegistry()` | Clear all registrations |
+
+### Testing
+
+| Export | Description |
+|--------|-------------|
+| `setupTestTenancy(options?)` | Enable tenancy for tests |
+| `resetTenancy()` | Clean up tenancy state between tests |
+| `createTestTenantContext(ctx, fn)` | Run test code in tenant context |
+| `testTenantIsolation(tenantIds, fn)` | Verify isolation between tenants |
+| `assertTenantContextRequired(fn)` | Assert operation requires context |
+| `assertTenantIsolationViolation(fn)` | Assert operation violates isolation |
+
+## Dependencies
+
+- `@happyvertical/smrt-core` -- SmrtObject, SmrtCollection, GlobalInterceptors
+- `@happyvertical/sql` -- database operations
+- `@happyvertical/utils` -- utility functions
+
+Optional peers: `svelte`, `@happyvertical/smrt-users`, `@happyvertical/smrt-svelte`
+
+## License
+
+MIT

package/dist/__smrt-register__.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=__smrt-register__.d.ts.map

package/dist/__smrt-register__.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"__smrt-register__.d.ts","sourceRoot":"","sources":["../src/__smrt-register__.ts"],"names":[],"mappings":""}

package/dist/adapters/cli.d.ts

@@ -0,0 +1,178 @@
+/**
+ * CLI Adapter for smrt-tenancy
+ *
+ * Provides utilities for setting up tenant context in CLI tools.
+ *
+ * @example
+ * ```typescript
+ * import { createCliContext } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * // Create context helper for CLI
+ * const cliContext = createCliContext({
+ *   resolveTenantId: () => process.env.TENANT_ID,
+ * });
+ *
+ * // Run command in tenant context
+ * await cliContext.run(async () => {
+ *   await documentCollection.list({});
+ * });
+ * ```
+ */
+/**
+ * Configuration for the CLI context runner created by `createCliContext()`.
+ *
+ * `resolveTenantId` is optional — when omitted (or when it returns
+ * `null`/`undefined`) the `run()` method falls back to `withSystemContext()`.
+ *
+ * @see createCliContext
+ * @see CliContextRunner
+ */
+export interface CliContextOptions {
+    /**
+     * Resolve tenant ID
+     *
+     * Common sources:
+     * - Environment variable: () => process.env.TENANT_ID
+     * - Command line argument: () => argv.tenant
+     * - Config file: () => config.tenantId
+     */
+    resolveTenantId?: () => Promise<string | null | undefined> | string | null | undefined;
+    /**
+     * Resolve user ID (optional)
+     */
+    resolveUserId?: () => Promise<string | null | undefined> | string | null | undefined;
+    /**
+     * Default permissions for CLI operations
+     */
+    defaultPermissions?: Set<string>;
+    /**
+     * Run CLI as super admin by default
+     * @default false
+     */
+    superAdminByDefault?: boolean;
+}
+/**
+ * Context runner returned by `createCliContext()`.
+ *
+ * Provides four execution modes suitable for different CLI scenarios:
+ * - `run()` — resolves the tenant from the configured options and runs code in
+ *   that context; falls back to system context if no tenant is available.
+ * - `runWithTenant()` — explicitly specify a tenant ID for this invocation.
+ * - `runAsSystem()` — bypass all tenant checks (migration scripts, admin tools).
+ * - `runAsSuperAdmin()` — tenant context with bypass flag enabled.
+ *
+ * @see createCliContext
+ */
+export interface CliContextRunner {
+    /**
+     * Run `fn` inside the tenant context resolved from the `CliContextOptions`.
+     *
+     * Falls back to `withSystemContext()` when no tenant ID is available.
+     *
+     * @param fn - Async function to execute.
+     * @returns Promise resolving to the return value of `fn`.
+     */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Run `fn` inside the context of the specified tenant.
+     *
+     * @param tenantId - Tenant ID to set as context.
+     * @param fn - Async function to execute.
+     * @returns Promise resolving to the return value of `fn`.
+     */
+    runWithTenant<T>(tenantId: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Run `fn` in system context, bypassing all tenant checks.
+     *
+     * @param fn - Async function to execute.
+     * @returns Promise resolving to the return value of `fn`.
+     */
+    runAsSystem<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Run `fn` with a tenant context and super admin bypass enabled.
+     *
+     * @param tenantId - Tenant ID to set as context.
+     * @param fn - Async function to execute.
+     * @returns Promise resolving to the return value of `fn`.
+     */
+    runAsSuperAdmin<T>(tenantId: string, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Create a CLI context runner
+ *
+ * @param options - Configuration options
+ * @returns CLI context runner with various execution modes
+ *
+ * @example
+ * ```typescript
+ * const cli = createCliContext({
+ *   resolveTenantId: () => process.env.TENANT_ID,
+ *   superAdminByDefault: true,
+ * });
+ *
+ * // Use resolved tenant
+ * await cli.run(async () => {
+ *   const docs = await collection.list({});
+ *   console.log(`Found ${docs.length} documents`);
+ * });
+ *
+ * // Override tenant
+ * await cli.runWithTenant('other-tenant', async () => {
+ *   // Operations in other-tenant context
+ * });
+ *
+ * // System operations (no tenant)
+ * await cli.runAsSystem(async () => {
+ *   // Can access all data
+ *   const allDocs = await collection.list({});
+ * });
+ * ```
+ */
+export declare function createCliContext(options?: CliContextOptions): CliContextRunner;
+/**
+ * Run an async function with a specific tenant ID set as context.
+ *
+ * Convenience wrapper around `withTenant()` for one-off CLI operations where
+ * a full `CliContextRunner` is not needed.
+ *
+ * @param tenantId - Tenant ID to set as the active context.
+ * @param fn - Async function to execute in the tenant context.
+ * @returns Promise resolving to the return value of `fn`.
+ *
+ * @example
+ * ```typescript
+ * import { runWithTenant } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * await runWithTenant('tenant-123', async () => {
+ *   await collection.list({});
+ * });
+ * ```
+ *
+ * @see createCliContext
+ * @see runAsSystem
+ */
+export declare function runWithTenant<T>(tenantId: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Run an async function in system context, bypassing all tenant checks.
+ *
+ * Convenience wrapper around `withSystemContext()` for one-off CLI operations
+ * such as migration scripts or admin tooling that needs cross-tenant access.
+ *
+ * @param fn - Async function to execute in system context.
+ * @returns Promise resolving to the return value of `fn`.
+ *
+ * @example
+ * ```typescript
+ * import { runAsSystem } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * await runAsSystem(async () => {
+ *   const all = await collection.list({});
+ *   console.log(`Total records: ${all.length}`);
+ * });
+ * ```
+ *
+ * @see runWithTenant
+ * @see createCliContext
+ */
+export declare function runAsSystem<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/adapters/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/adapters/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MACd,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAClC,MAAM,GACN,IAAI,GACJ,SAAS,CAAC;IAEd;;OAEG;IACH,aAAa,CAAC,EAAE,MACZ,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAClC,MAAM,GACN,IAAI,GACJ,SAAS,CAAC;IAEd;;OAEG;IACH,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAEjC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;OAOG;IACH,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEzC;;;;;;OAMG;IACH,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAErE;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEjD;;;;;;OAMG;IACH,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACxE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CA8DlB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAErE"}

package/dist/adapters/express.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Express Adapter for smrt-tenancy
+ *
+ * Provides Express middleware that sets up tenant context for each request.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createExpressMiddleware } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * const app = express();
+ *
+ * app.use(createExpressMiddleware({
+ *   resolveTenantId: (req) => req.headers['x-tenant-id'] as string,
+ * }));
+ * ```
+ */
+/**
+ * Express Request interface (minimal to avoid direct dependency)
+ */
+interface ExpressRequest {
+    headers: Record<string, string | string[] | undefined>;
+    url: string;
+    path: string;
+    query: Record<string, unknown>;
+    cookies?: Record<string, string>;
+}
+/**
+ * Express Response interface
+ */
+interface ExpressResponse {
+    status(code: number): ExpressResponse;
+    json(data: unknown): ExpressResponse;
+    send(data: unknown): ExpressResponse;
+}
+/**
+ * Express NextFunction
+ */
+type ExpressNext = (error?: unknown) => void;
+/**
+ * Configuration options for the Express tenancy middleware created by
+ * `createExpressMiddleware()`.
+ *
+ * Only `resolveTenantId` is required.  All callback options receive the raw
+ * Express `Request` object so you can extract tenant information from headers,
+ * subdomains, cookies, or any other request property.
+ *
+ * @see createExpressMiddleware
+ */
+export interface ExpressMiddlewareOptions {
+    /**
+     * Resolve tenant ID from the request
+     */
+    resolveTenantId: (req: ExpressRequest) => Promise<string | null | undefined> | string | null | undefined;
+    /**
+     * Resolve user ID from the request (optional)
+     */
+    resolveUserId?: (req: ExpressRequest) => Promise<string | null | undefined> | string | null | undefined;
+    /**
+     * Resolve permissions (optional)
+     */
+    resolvePermissions?: (req: ExpressRequest, tenantId: string, userId?: string) => Promise<Set<string>> | Set<string>;
+    /**
+     * Check if user is super admin (optional)
+     */
+    isSuperAdmin?: (req: ExpressRequest, tenantId: string, userId?: string) => Promise<boolean> | boolean;
+    /**
+     * Called when no tenant ID could be resolved
+     * Return true to continue, false to stop with 400 error.
+     */
+    onNoTenant?: (req: ExpressRequest, res: ExpressResponse) => Promise<boolean> | boolean;
+    /**
+     * Paths to exclude from tenant context
+     */
+    excludePaths?: string[];
+}
+/**
+ * Create an Express middleware function that establishes tenant context for
+ * every incoming request.
+ *
+ * Uses `enterTenantContext()` (rather than `withTenant()`) because Express
+ * middleware returns before route handlers execute.  `enterWith()` sets the
+ * context on the current async resource so it propagates to handlers that run
+ * after `next()` is called.
+ *
+ * The resolved context is also attached directly to the request object for
+ * convenience:
+ * - `req.tenantContext` — full `TenantContextData`
+ * - `req.tenantId`      — string tenant ID shortcut
+ *
+ * When no tenant ID can be resolved, the default behaviour returns a `400`
+ * JSON response.  Customise this with the `onNoTenant` option.
+ *
+ * @param options - Middleware configuration including the required
+ *   `resolveTenantId` callback.
+ * @returns An Express-compatible middleware function `(req, res, next) => void`.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createExpressMiddleware } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * const app = express();
+ * app.use(createExpressMiddleware({
+ *   resolveTenantId: (req) => req.headers['x-tenant-id'] as string,
+ *   excludePaths: ['/health', '/public/*'],
+ * }));
+ * ```
+ *
+ * @see ExpressMiddlewareOptions
+ * @see createSvelteKitHandle
+ */
+export declare function createExpressMiddleware(options: ExpressMiddlewareOptions): (req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => Promise<void>;
+export {};
+//# sourceMappingURL=express.d.ts.map

package/dist/adapters/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../src/adapters/express.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;GAEG;AACH,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,UAAU,eAAe;IACvB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC;IACtC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAAC;IACrC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAAC;CACtC;AAED;;GAEG;AACH,KAAK,WAAW,GAAG,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,eAAe,EAAE,CACf,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAEpE;;OAEG;IACH,aAAa,CAAC,EAAE,CACd,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAEpE;;OAEG;IACH,kBAAkB,CAAC,EAAE,CACnB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,KACZ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;IAExC;;OAEG;IACH,YAAY,CAAC,EAAE,CACb,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,KACZ,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAEhC;;;OAGG;IACH,UAAU,CAAC,EAAE,CACX,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,eAAe,KACjB,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAEhC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,IAWrE,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,MAAM,WAAW,KAChB,OAAO,CAAC,IAAI,CAAC,CA2DjB"}

package/dist/adapters/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Framework Adapters for smrt-tenancy
+ *
+ * Provides middleware/hooks for popular frameworks to set up tenant context.
+ *
+ * @example SvelteKit
+ * ```typescript
+ * // hooks.server.ts
+ * import { createSvelteKitHandle } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * export const handle = createSvelteKitHandle({
+ *   resolveTenantId: async (event) => {
+ *     // Get from subdomain, header, cookie, etc.
+ *     return event.request.headers.get('x-tenant-id');
+ *   }
+ * });
+ * ```
+ */
+export { type CliContextOptions, createCliContext } from './cli.js';
+export { createExpressMiddleware, type ExpressMiddlewareOptions, } from './express.js';
+export { createSvelteKitHandle, type SvelteKitHandleOptions, } from './sveltekit.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,GAC9B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,qBAAqB,EACrB,KAAK,sBAAsB,GAC5B,MAAM,gBAAgB,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,7 @@
+import { c, a, b } from "../chunks/sveltekit-9eRH1RLw.js";
+export {
+  c as createCliContext,
+  a as createExpressMiddleware,
+  b as createSvelteKitHandle
+};
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/adapters/sveltekit.d.ts

@@ -0,0 +1,123 @@
+/**
+ * SvelteKit Adapter for smrt-tenancy
+ *
+ * Provides a SvelteKit Handle that sets up tenant context for each request.
+ *
+ * @example
+ * ```typescript
+ * // hooks.server.ts
+ * import { createSvelteKitHandle } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * export const handle = createSvelteKitHandle({
+ *   resolveTenantId: async (event) => {
+ *     // From subdomain
+ *     const host = event.request.headers.get('host');
+ *     const subdomain = host?.split('.')[0];
+ *     return subdomain;
+ *
+ *     // Or from header
+ *     // return event.request.headers.get('x-tenant-id');
+ *
+ *     // Or from cookie
+ *     // return event.cookies.get('tenant_id');
+ *   }
+ * });
+ * ```
+ */
+/**
+ * SvelteKit RequestEvent (minimal interface to avoid direct dependency)
+ */
+interface SvelteKitEvent {
+    request: Request;
+    url: URL;
+    cookies: {
+        get(name: string): string | undefined;
+        set(name: string, value: string, opts?: unknown): void;
+    };
+    locals: Record<string, unknown>;
+}
+/**
+ * SvelteKit resolve function
+ */
+type SvelteKitResolve = (event: SvelteKitEvent) => Promise<Response>;
+/**
+ * Configuration options for the SvelteKit tenancy handle created by
+ * `createSvelteKitHandle()`.
+ *
+ * Only `resolveTenantId` is required; all other fields are optional callbacks
+ * used to enrich the context or customise missing-tenant behaviour.
+ *
+ * @see createSvelteKitHandle
+ */
+export interface SvelteKitHandleOptions {
+    /**
+     * Resolve tenant ID from the request
+     *
+     * Return the tenant ID string, or null/undefined if no tenant context should be set.
+     */
+    resolveTenantId: (event: SvelteKitEvent) => Promise<string | null | undefined> | string | null | undefined;
+    /**
+     * Resolve user ID from the request (optional)
+     */
+    resolveUserId?: (event: SvelteKitEvent) => Promise<string | null | undefined> | string | null | undefined;
+    /**
+     * Resolve permissions for the user in this tenant (optional)
+     */
+    resolvePermissions?: (event: SvelteKitEvent, tenantId: string, userId?: string) => Promise<Set<string>> | Set<string>;
+    /**
+     * Check if user is a super admin (optional)
+     * If true and super admin bypass is enabled on the class, tenant filtering is skipped.
+     */
+    isSuperAdmin?: (event: SvelteKitEvent, tenantId: string, userId?: string) => Promise<boolean> | boolean;
+    /**
+     * Called when no tenant ID could be resolved
+     * Return a Response to short-circuit, or undefined to continue without tenant context.
+     */
+    onNoTenant?: (event: SvelteKitEvent) => Promise<Response | undefined> | Response | undefined;
+    /**
+     * Paths to exclude from tenant context (e.g., public APIs, health checks)
+     * Supports glob patterns.
+     */
+    excludePaths?: string[];
+}
+/**
+ * Create a SvelteKit `Handle` function that establishes tenant context for
+ * every server-side request.
+ *
+ * The returned handle wraps the `resolve` call in `withTenant()` so that all
+ * server-side load functions, API routes, and `+server.ts` handlers within the
+ * request share the same tenant context via `AsyncLocalStorage`.
+ *
+ * The resolved context is also stored in `event.locals` under two keys:
+ * - `event.locals.tenantContext` — full `TenantContextData`
+ * - `event.locals.tenantId`      — string tenant ID shortcut
+ *
+ * When no tenant ID can be resolved (and no custom `onNoTenant` handler
+ * returns a `Response`), the request continues without any tenant context.
+ *
+ * @param options - Configuration options including the required
+ *   `resolveTenantId` callback.
+ * @returns A SvelteKit `Handle` function suitable for use in `hooks.server.ts`.
+ *
+ * @example
+ * ```typescript
+ * // src/hooks.server.ts
+ * import { createSvelteKitHandle } from '@happyvertical/smrt-tenancy/adapters';
+ *
+ * export const handle = createSvelteKitHandle({
+ *   resolveTenantId: (event) =>
+ *     event.request.headers.get('x-tenant-id'),
+ *   onNoTenant: () =>
+ *     new Response('Tenant required', { status: 400 }),
+ * });
+ * ```
+ *
+ * @see SvelteKitHandleOptions
+ * @see createExpressMiddleware
+ */
+export declare function createSvelteKitHandle(options: SvelteKitHandleOptions): ({ event, resolve, }: {
+    event: SvelteKitEvent;
+    resolve: SvelteKitResolve;
+}) => Promise<Response>;
+export {};
+//# sourceMappingURL=sveltekit.d.ts.map