@nebutra/tenant 0.1.0 → 0.1.1

package/dist/react.d.ts

@@ -0,0 +1,211 @@
+import React from "react";
+import type { TenantContext } from "./types";
+/**
+ * Provider component that wraps your app with tenant context.
+ *
+ * @param children Child components to wrap
+ * @param value The tenant context value (usually from server)
+ *
+ * @example
+ * ```tsx
+ * // layout.tsx
+ * import { TenantProvider } from "@nebutra/tenant/react";
+ * import { getTenantContext } from "@/lib/tenant-server";
+ *
+ * export default async function RootLayout() {
+ *   const tenant = await getTenantContext();
+ *
+ *   return (
+ *     <TenantProvider value={tenant}>
+ *       <MainApp />
+ *     </TenantProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function TenantProvider({ children, value, }: {
+    children: React.ReactNode;
+    value: TenantContext;
+}): React.FunctionComponentElement<React.ProviderProps<{
+    id: string;
+    slug?: string | undefined;
+    plan?: "free" | "pro" | "enterprise" | undefined;
+    features?: string[] | undefined;
+    limits?: Record<string, number> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+} | null>>;
+/**
+ * Hook to access the current tenant context from client-side components.
+ *
+ * Throws an error if no tenant context is available.
+ * Use `useTenantOrNull()` for optional tenant contexts.
+ *
+ * @returns The current tenant context
+ * @throws TenantRequiredError if tenant context is not available
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenant = useTenant();
+ *
+ *   return <div>Current tenant: {tenant.id}</div>;
+ * }
+ * ```
+ */
+export declare function useTenant(): TenantContext;
+/**
+ * Hook to access the current tenant context or null if not available.
+ *
+ * Useful for components that work in both tenant and non-tenant contexts
+ * (e.g., public pages, webhooks, etc).
+ *
+ * @returns The current tenant context, or null
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenant = useTenantOrNull();
+ *
+ *   if (!tenant) {
+ *     return <div>Public content</div>;
+ *   }
+ *
+ *   return <div>Tenant-specific content for {tenant.id}</div>;
+ * }
+ * ```
+ */
+export declare function useTenantOrNull(): TenantContext | null;
+/**
+ * Hook to get just the tenant ID from context.
+ *
+ * Shorthand for `useTenant().id`.
+ *
+ * @returns The current tenant's ID
+ * @throws TenantRequiredError if tenant context is not available
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenantId = useTenantId();
+ *
+ *   return <div>Tenant: {tenantId}</div>;
+ * }
+ * ```
+ */
+export declare function useTenantId(): string;
+/**
+ * Hook to get just the tenant ID, or null if not available.
+ *
+ * @returns The current tenant's ID, or null
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenantId = useTenantIdOrNull();
+ *   return <div>{tenantId ? `Tenant: ${tenantId}` : "Public"}</div>;
+ * }
+ * ```
+ */
+export declare function useTenantIdOrNull(): string | null;
+/**
+ * Hook to get the tenant's plan tier.
+ *
+ * @returns The current tenant's plan ("free", "pro", "enterprise"), or undefined
+ *
+ * @example
+ * ```tsx
+ * function PremiumFeature() {
+ *   const plan = useTenantPlan();
+ *
+ *   if (plan === "free") {
+ *     return <UpgradePrompt />;
+ *   }
+ *
+ *   return <Feature />;
+ * }
+ * ```
+ */
+export declare function useTenantPlan(): "free" | "pro" | "enterprise" | undefined;
+/**
+ * Hook to check if a specific feature is enabled for the tenant.
+ *
+ * @param feature The feature flag name
+ * @returns Whether the feature is enabled
+ *
+ * @example
+ * ```tsx
+ * function DashboardPage() {
+ *   const hasAdvancedAnalytics = useTenantFeature("advanced_analytics");
+ *
+ *   return (
+ *     <>
+ *       {hasAdvancedAnalytics && <AdvancedAnalytics />}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTenantFeature(feature: string): boolean;
+/**
+ * Hook to get a rate limit or quota for the tenant.
+ *
+ * @param limitName The limit name (e.g., "requests_per_minute", "storage_gb")
+ * @param defaultValue Default value if limit is not set
+ * @returns The limit value, or default if not set
+ *
+ * @example
+ * ```tsx
+ * function ApiDashboard() {
+ *   const rateLimit = useTenantLimit("requests_per_minute", 100);
+ *
+ *   return <div>Rate limit: {rateLimit} req/min</div>;
+ * }
+ * ```
+ */
+export declare function useTenantLimit(limitName: string, defaultValue?: number): number | undefined;
+/**
+ * Higher-order component that requires tenant context.
+ *
+ * Wraps a component and throws an error if no tenant context is available.
+ * Useful as a safety check for tenant-specific features.
+ *
+ * @param Component The component to wrap
+ * @param errorFallback Optional fallback component if tenant is missing
+ * @returns A wrapped component
+ *
+ * @example
+ * ```tsx
+ * function DashboardContent() {
+ *   const tenantId = useTenantId();
+ *   return <div>Dashboard for {tenantId}</div>;
+ * }
+ *
+ * export default withTenantGuard(DashboardContent);
+ * ```
+ */
+export declare function withTenantGuard<P extends object>(Component: React.ComponentType<P>, errorFallback?: React.ComponentType<{
+    error: Error;
+}>): {
+    (props: P): React.ReactElement<P, string | React.JSXElementConstructor<any>> | React.ReactElement<{
+        error: Error;
+    }, string | React.JSXElementConstructor<any>>;
+    displayName: string;
+};
+/**
+ * Component that renders children only if tenant context is available.
+ *
+ * @param children Children to render if tenant is available
+ * @param fallback Optional fallback if tenant is missing
+ *
+ * @example
+ * ```tsx
+ * <TenantBoundary fallback={<PublicPage />}>
+ *   <DashboardPage />
+ * </TenantBoundary>
+ * ```
+ */
+export declare function TenantBoundary({ children, fallback, }: {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}): React.FunctionComponentElement<React.FragmentProps>;
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.ts"],"names":[],"mappings":"AAEA,OAAO,KAAoC,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAe7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,EAAE,aAAa,CAAC;CACtB;;;;;;;WAMA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,IAAI,aAAa,CAUzC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,IAAI,aAAa,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAGpC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAEjD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,8CAG5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EACjC,aAAa,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;YAEpB,CAAC;eAFW,KAAK;;;EAqBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B,uDAYA"}

package/dist/react.js

@@ -0,0 +1,252 @@
+"use client";
+import React, { createContext, useContext } from "react";
+import { TenantRequiredError } from "./types";
+// =============================================================================
+// React Context for Tenant — Client-side multi-tenancy
+// =============================================================================
+/**
+ * React context that provides tenant information to client-side components.
+ *
+ * Usually populated by middleware that reads the tenant from request headers
+ * or URL and passes it as a prop to the Next.js layout or page component.
+ */
+const TenantContextValue = createContext(null);
+/**
+ * Provider component that wraps your app with tenant context.
+ *
+ * @param children Child components to wrap
+ * @param value The tenant context value (usually from server)
+ *
+ * @example
+ * ```tsx
+ * // layout.tsx
+ * import { TenantProvider } from "@nebutra/tenant/react";
+ * import { getTenantContext } from "@/lib/tenant-server";
+ *
+ * export default async function RootLayout() {
+ *   const tenant = await getTenantContext();
+ *
+ *   return (
+ *     <TenantProvider value={tenant}>
+ *       <MainApp />
+ *     </TenantProvider>
+ *   );
+ * }
+ * ```
+ */
+export function TenantProvider({ children, value, }) {
+    if (!value || !value.id) {
+        console.warn("TenantProvider: No tenant value provided");
+    }
+    return React.createElement(TenantContextValue.Provider, { value: value ?? null }, children);
+}
+/**
+ * Hook to access the current tenant context from client-side components.
+ *
+ * Throws an error if no tenant context is available.
+ * Use `useTenantOrNull()` for optional tenant contexts.
+ *
+ * @returns The current tenant context
+ * @throws TenantRequiredError if tenant context is not available
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenant = useTenant();
+ *
+ *   return <div>Current tenant: {tenant.id}</div>;
+ * }
+ * ```
+ */
+export function useTenant() {
+    const context = useContext(TenantContextValue);
+    if (!context) {
+        throw new TenantRequiredError("useTenant must be used within a TenantProvider that has a tenant value");
+    }
+    return context;
+}
+/**
+ * Hook to access the current tenant context or null if not available.
+ *
+ * Useful for components that work in both tenant and non-tenant contexts
+ * (e.g., public pages, webhooks, etc).
+ *
+ * @returns The current tenant context, or null
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenant = useTenantOrNull();
+ *
+ *   if (!tenant) {
+ *     return <div>Public content</div>;
+ *   }
+ *
+ *   return <div>Tenant-specific content for {tenant.id}</div>;
+ * }
+ * ```
+ */
+export function useTenantOrNull() {
+    return useContext(TenantContextValue);
+}
+/**
+ * Hook to get just the tenant ID from context.
+ *
+ * Shorthand for `useTenant().id`.
+ *
+ * @returns The current tenant's ID
+ * @throws TenantRequiredError if tenant context is not available
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenantId = useTenantId();
+ *
+ *   return <div>Tenant: {tenantId}</div>;
+ * }
+ * ```
+ */
+export function useTenantId() {
+    const tenant = useTenant();
+    return tenant.id;
+}
+/**
+ * Hook to get just the tenant ID, or null if not available.
+ *
+ * @returns The current tenant's ID, or null
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const tenantId = useTenantIdOrNull();
+ *   return <div>{tenantId ? `Tenant: ${tenantId}` : "Public"}</div>;
+ * }
+ * ```
+ */
+export function useTenantIdOrNull() {
+    return useTenantOrNull()?.id ?? null;
+}
+/**
+ * Hook to get the tenant's plan tier.
+ *
+ * @returns The current tenant's plan ("free", "pro", "enterprise"), or undefined
+ *
+ * @example
+ * ```tsx
+ * function PremiumFeature() {
+ *   const plan = useTenantPlan();
+ *
+ *   if (plan === "free") {
+ *     return <UpgradePrompt />;
+ *   }
+ *
+ *   return <Feature />;
+ * }
+ * ```
+ */
+export function useTenantPlan() {
+    const tenant = useTenant();
+    return tenant.plan;
+}
+/**
+ * Hook to check if a specific feature is enabled for the tenant.
+ *
+ * @param feature The feature flag name
+ * @returns Whether the feature is enabled
+ *
+ * @example
+ * ```tsx
+ * function DashboardPage() {
+ *   const hasAdvancedAnalytics = useTenantFeature("advanced_analytics");
+ *
+ *   return (
+ *     <>
+ *       {hasAdvancedAnalytics && <AdvancedAnalytics />}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export function useTenantFeature(feature) {
+    const tenant = useTenant();
+    return tenant.features?.includes(feature) ?? false;
+}
+/**
+ * Hook to get a rate limit or quota for the tenant.
+ *
+ * @param limitName The limit name (e.g., "requests_per_minute", "storage_gb")
+ * @param defaultValue Default value if limit is not set
+ * @returns The limit value, or default if not set
+ *
+ * @example
+ * ```tsx
+ * function ApiDashboard() {
+ *   const rateLimit = useTenantLimit("requests_per_minute", 100);
+ *
+ *   return <div>Rate limit: {rateLimit} req/min</div>;
+ * }
+ * ```
+ */
+export function useTenantLimit(limitName, defaultValue) {
+    const tenant = useTenant();
+    return tenant.limits?.[limitName] ?? defaultValue;
+}
+/**
+ * Higher-order component that requires tenant context.
+ *
+ * Wraps a component and throws an error if no tenant context is available.
+ * Useful as a safety check for tenant-specific features.
+ *
+ * @param Component The component to wrap
+ * @param errorFallback Optional fallback component if tenant is missing
+ * @returns A wrapped component
+ *
+ * @example
+ * ```tsx
+ * function DashboardContent() {
+ *   const tenantId = useTenantId();
+ *   return <div>Dashboard for {tenantId}</div>;
+ * }
+ *
+ * export default withTenantGuard(DashboardContent);
+ * ```
+ */
+export function withTenantGuard(Component, errorFallback) {
+    const WrappedComponent = (props) => {
+        try {
+            // Verify tenant context is available by calling hook
+            useTenant();
+            return React.createElement(Component, props);
+        }
+        catch (err) {
+            if (errorFallback) {
+                const ErrorComponent = errorFallback;
+                return React.createElement(ErrorComponent, { error: err });
+            }
+            // Re-throw if no fallback provided
+            throw err;
+        }
+    };
+    WrappedComponent.displayName = `withTenantGuard(${Component.displayName || Component.name})`;
+    return WrappedComponent;
+}
+/**
+ * Component that renders children only if tenant context is available.
+ *
+ * @param children Children to render if tenant is available
+ * @param fallback Optional fallback if tenant is missing
+ *
+ * @example
+ * ```tsx
+ * <TenantBoundary fallback={<PublicPage />}>
+ *   <DashboardPage />
+ * </TenantBoundary>
+ * ```
+ */
+export function TenantBoundary({ children, fallback, }) {
+    const tenant = useTenantOrNull();
+    if (!tenant) {
+        return React.createElement(React.Fragment, null, fallback ?? React.createElement("div", null, "No tenant context available"));
+    }
+    return React.createElement(React.Fragment, null, children);
+}

package/dist/resolvers/from-auth-session.d.ts

@@ -0,0 +1,48 @@
+import type { TenantResolver } from "../types";
+/**
+ * Minimal shape this resolver needs from a session object.
+ *
+ * Structurally compatible with `Session` from `@nebutra/auth` but defined
+ * locally so `@nebutra/tenant` stays IAM-neutral — there is no hard dep on
+ * `@nebutra/auth`. Callers pass in their own session getter (typically
+ * `(req) => auth.getSession(req)`), keeping the dependency direction one-way:
+ * apps depend on both packages; neither package depends on the other.
+ */
+export interface AuthSessionLike {
+    organizationId?: string;
+}
+/**
+ * Function that retrieves an auth session from a resolver-input request.
+ *
+ * Receives the same request envelope as any other {@link TenantResolver}
+ * (`{ headers?, url?, token?, apiKey? }`). Returns either an `AuthSessionLike`
+ * or `null` when no session exists. May be sync or async.
+ */
+export type SessionGetter = (req: Parameters<TenantResolver>[0]) => Promise<AuthSessionLike | null> | AuthSessionLike | null;
+/**
+ * Resolve `tenantId` from an auth session's `organizationId`.
+ *
+ * This is the canonical bridge between `Session.organizationId` (from
+ * `@nebutra/auth`) and the tenant context. It is the standard second link in
+ * the resolver chain — after `fromHeader` (service-to-service) and before any
+ * fallback strategy.
+ *
+ * @example
+ * ```ts
+ * import { createAuth } from "@nebutra/auth/server";
+ * import { tenantMiddleware, compose, fromHeader, fromAuthSession } from "@nebutra/tenant";
+ *
+ * const auth = await createAuth({ provider: "better-auth" });
+ *
+ * app.use(
+ *   tenantMiddleware({
+ *     resolver: compose(
+ *       fromHeader("x-tenant-id"),           // service-to-service wins
+ *       fromAuthSession(() => auth.getSession()), // then user-session
+ *     ),
+ *   }),
+ * );
+ * ```
+ */
+export declare function fromAuthSession(getSession: SessionGetter): TenantResolver;
+//# sourceMappingURL=from-auth-session.d.ts.map

package/dist/resolvers/from-auth-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-auth-session.d.ts","sourceRoot":"","sources":["../../src/resolvers/from-auth-session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAM/C;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,GAAG,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,eAAe,GAAG,IAAI,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,aAAa,GAAG,cAAc,CAgBzE"}

package/dist/resolvers/from-auth-session.js

@@ -0,0 +1,41 @@
+import { logger } from "@nebutra/logger";
+/**
+ * Resolve `tenantId` from an auth session's `organizationId`.
+ *
+ * This is the canonical bridge between `Session.organizationId` (from
+ * `@nebutra/auth`) and the tenant context. It is the standard second link in
+ * the resolver chain — after `fromHeader` (service-to-service) and before any
+ * fallback strategy.
+ *
+ * @example
+ * ```ts
+ * import { createAuth } from "@nebutra/auth/server";
+ * import { tenantMiddleware, compose, fromHeader, fromAuthSession } from "@nebutra/tenant";
+ *
+ * const auth = await createAuth({ provider: "better-auth" });
+ *
+ * app.use(
+ *   tenantMiddleware({
+ *     resolver: compose(
+ *       fromHeader("x-tenant-id"),           // service-to-service wins
+ *       fromAuthSession(() => auth.getSession()), // then user-session
+ *     ),
+ *   }),
+ * );
+ * ```
+ */
+export function fromAuthSession(getSession) {
+    return async (req) => {
+        // Intentionally NOT wrapped in try/catch — errors propagate to the
+        // caller (typically the `compose` chain, which logs + continues to the
+        // next resolver). Silently swallowing here would mask real auth bugs.
+        const session = await Promise.resolve(getSession(req));
+        if (session?.organizationId) {
+            logger.debug("Tenant resolved from auth session", {
+                tenantId: session.organizationId,
+            });
+            return session.organizationId;
+        }
+        return null;
+    };
+}

package/dist/resolvers.d.ts

@@ -0,0 +1,110 @@
+import type { TenantResolver } from "./types";
+/**
+ * Extract tenant ID from an HTTP header.
+ *
+ * Default strategy for API gateways. Header name is configurable.
+ *
+ * @param headerName The header name to look for (default: "x-tenant-id")
+ * @returns A resolver function
+ *
+ * @example
+ * ```ts
+ * const resolver = fromHeader("x-tenant-id");
+ * const tenantId = await resolver({ headers: { "x-tenant-id": "org_123" } });
+ * ```
+ */
+export declare function fromHeader(headerName?: string): TenantResolver;
+/**
+ * Extract tenant ID from a subdomain using a regex pattern.
+ *
+ * Useful for SaaS products with tenant subdomains (e.g., `acme.app.nebutra.com`).
+ *
+ * @param pattern A regex pattern with a capture group for tenant ID
+ * @returns A resolver function
+ *
+ * @example
+ * ```ts
+ * // Extract "acme" from "acme.app.nebutra.com"
+ * const resolver = fromSubdomain("^([a-z0-9-]+)\\.app\\.nebutra\\.com$");
+ * const tenantId = await resolver({ url: "https://acme.app.nebutra.com/api" });
+ * ```
+ */
+export declare function fromSubdomain(pattern: string): TenantResolver;
+/**
+ * Extract tenant ID from a URL path prefix.
+ *
+ * Useful for multi-tenant apps with path-based routing (e.g., `/org/acme/...`).
+ *
+ * @param prefix The path prefix pattern (e.g., "/org/:tenantId" or "/org/([^/]+)")
+ * @returns A resolver function
+ *
+ * @example
+ * ```ts
+ * // Extract tenant ID from "/org/acme/..."
+ * const resolver = fromPath("/org/:tenantId");
+ * const tenantId = await resolver({ url: "https://app.nebutra.com/org/acme/dashboard" });
+ * ```
+ */
+export declare function fromPath(prefix: string): TenantResolver;
+/**
+ * Extract tenant ID from a JWT token claim.
+ *
+ * Useful for authentication services that embed tenant info in the token.
+ *
+ * @param claimName The JWT claim name (e.g., "tenant_id", "org_id")
+ * @returns A resolver function
+ *
+ * @example
+ * ```ts
+ * // Extract from decoded JWT { sub: "user_123", tenant_id: "org_456" }
+ * const resolver = fromJwtClaim("tenant_id");
+ * const tenantId = await resolver({ token: "eyJhbGc..." });
+ * ```
+ */
+export declare function fromJwtClaim(claimName: string): TenantResolver;
+/**
+ * Resolve tenant ID from an API key by looking it up in a function (e.g., database).
+ *
+ * Useful for service-to-service authentication or API clients.
+ *
+ * @param lookupFn Async function that takes an API key and returns the tenant ID
+ * @returns A resolver function
+ *
+ * @example
+ * ```ts
+ * // Look up API key in database
+ * const resolver = fromApiKey(async (apiKey) => {
+ *   const key = await db.apiKey.findUnique({ where: { key: apiKey } });
+ *   return key?.tenantId ?? null;
+ * });
+ * const tenantId = await resolver({ apiKey: "sk_123" });
+ * ```
+ */
+export declare function fromApiKey(lookupFn: (apiKey: string) => Promise<string | null>): TenantResolver;
+/**
+ * Compose multiple tenant resolvers with fallback behavior.
+ *
+ * Tries each resolver in order; returns the first successful match.
+ * If all resolvers return null, returns null.
+ *
+ * @param resolvers Array of resolver functions
+ * @returns A composite resolver function
+ *
+ * @example
+ * ```ts
+ * // Try header first, then subdomain, then path
+ * const resolver = compose(
+ *   fromHeader("x-tenant-id"),
+ *   fromSubdomain("^([a-z0-9-]+)\\.app\\.nebutra\\.com$"),
+ *   fromPath("/org/:tenantId")
+ * );
+ *
+ * const tenantId = await resolver({
+ *   headers: { "x-tenant-id": "org_123" },
+ *   url: "https://acme.app.nebutra.com/org/xyz/dashboard"
+ * });
+ * // Returns "org_123" (first match)
+ * ```
+ */
+export declare function compose(...resolvers: TenantResolver[]): TenantResolver;
+//# sourceMappingURL=resolvers.d.ts.map

package/dist/resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../src/resolvers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAsD9C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,UAAU,GAAE,MAAsB,GAAG,cAAc,CAW7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAsB7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAwBvD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,CAsB9D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,cAAc,CAiB/F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CAAC,GAAG,SAAS,EAAE,cAAc,EAAE,GAAG,cAAc,CAiBtE"}