@usebetterdev/tenant-core 0.2.0-beta.9 → 0.3.0-beta.1

package/dist/index.js

@@ -16,7 +16,6 @@ function getTelemetryTenantConfig(config) {
       custom: !!r.custom
     },
     tenantTablesCount: 0,
-    hasGetTenantRepository: !!config.getTenantRepository,
     loadTenant: config.loadTenant,
     basePathSet: !!config.basePath,
     plugins: (config.plugins ?? []).map((p) => String(p.id))
@@ -326,7 +325,6 @@ async function handleRequest(request, next, options) {
 
 // src/api.ts
 var DEFAULT_LIST_LIMIT = 50;
-var MAX_LIST_LIMIT = 50;
 function requireRunAsSystem(adapter) {
   if (!adapter.runAsSystem) {
     throw new Error(
@@ -335,17 +333,7 @@ function requireRunAsSystem(adapter) {
   }
   return adapter.runAsSystem;
 }
-function requireTenantRepository(getTenantRepository) {
-  if (!getTenantRepository) {
-    throw new Error(
-      "better-tenant: tenant.api requires getTenantRepository in config (adapter provides CRUD for tenants table)"
-    );
-  }
-  return getTenantRepository;
-}
 function createTenantApi(adapter, getTenantRepository) {
-  const runAsSystem2 = requireRunAsSystem(adapter);
-  const getRepository = requireTenantRepository(getTenantRepository);
   return {
     async createTenant(data) {
       if (!data.name?.trim()) {
@@ -354,8 +342,9 @@ function createTenantApi(adapter, getTenantRepository) {
       if (!data.slug?.trim()) {
         throw new Error("better-tenant: createTenant requires slug");
       }
+      const runAsSystem2 = requireRunAsSystem(adapter);
       return runAsSystem2(
-        (database) => getRepository(database).create({
+        (database) => getTenantRepository(database).create({
           name: data.name.trim(),
           slug: data.slug.trim()
         })
@@ -365,29 +354,44 @@ function createTenantApi(adapter, getTenantRepository) {
       if (!tenantId?.trim()) {
         throw new Error("better-tenant: updateTenant requires tenantId");
       }
+      const runAsSystem2 = requireRunAsSystem(adapter);
       return runAsSystem2(
-        (database) => getRepository(database).update(tenantId, {
+        (database) => getTenantRepository(database).update(tenantId, {
           ...data.name !== void 0 && { name: data.name },
           ...data.slug !== void 0 && { slug: data.slug }
         })
       );
     },
     async listTenants(options = {}) {
-      const limit = Math.min(
-        options.limit ?? DEFAULT_LIST_LIMIT,
-        MAX_LIST_LIMIT
-      );
+      const limit = options.limit ?? DEFAULT_LIST_LIMIT;
       const offset = Math.max(0, options.offset ?? 0);
+      const runAsSystem2 = requireRunAsSystem(adapter);
       return runAsSystem2(
-        (database) => getRepository(database).list({ limit, offset })
+        (database) => getTenantRepository(database).list({ limit, offset })
       );
     },
     async deleteTenant(tenantId) {
       if (!tenantId?.trim()) {
         throw new Error("better-tenant: deleteTenant requires tenantId");
       }
+      const runAsSystem2 = requireRunAsSystem(adapter);
+      return runAsSystem2(
+        (database) => getTenantRepository(database).delete(tenantId)
+      );
+    },
+    async getTenant(tenantId) {
+      if (!tenantId?.trim()) {
+        throw new Error("better-tenant: getTenant requires tenantId");
+      }
+      const runAsSystem2 = requireRunAsSystem(adapter);
+      return runAsSystem2(
+        (database) => getTenantRepository(database).getById(tenantId)
+      );
+    },
+    async countTenants() {
+      const runAsSystem2 = requireRunAsSystem(adapter);
       return runAsSystem2(
-        (database) => getRepository(database).delete(tenantId)
+        (database) => getTenantRepository(database).count()
       );
     }
   };
@@ -397,7 +401,7 @@ async function runAs(tenantId, adapter, fn) {
 }
 async function runAsSystem(adapter, fn) {
   const run = requireRunAsSystem(adapter);
-  return runWithContext({ tenantId: "", isSystem: true }, () => run(fn));
+  return runWithContext({ isSystem: true }, () => run(fn));
 }
 
 // src/resolver.ts
@@ -479,39 +483,7 @@ function decodeJwtPayload(token) {
     return null;
   }
 }
-function resolveFromJwt(request, config) {
-  const getToken = request.getToken;
-  if (!getToken) {
-    return void 0;
-  }
-  const token = typeof getToken === "function" ? getToken() : getToken;
-  const value = token instanceof Promise ? void 0 : token ?? void 0;
-  const resolved = value ?? void 0;
-  if (!resolved) {
-    return void 0;
-  }
-  const claim = typeof config === "string" ? config : config.claim;
-  if (!claim) {
-    return void 0;
-  }
-  const verifyToken = typeof config === "object" ? config.verifyToken : void 0;
-  let payload;
-  if (verifyToken) {
-    const result = verifyToken(resolved);
-    if (result instanceof Promise) {
-      return void 0;
-    }
-    payload = result;
-  } else {
-    payload = decodeJwtPayload(resolved);
-  }
-  if (!payload) {
-    return void 0;
-  }
-  const claimValue = payload[claim];
-  return typeof claimValue === "string" && claimValue.length > 0 ? claimValue : void 0;
-}
-async function resolveFromJwtAsync(request, config) {
+async function resolveFromJwt(request, config) {
   const getToken = request.getToken;
   if (!getToken) {
     return void 0;
@@ -539,40 +511,28 @@ async function resolveFromJwtAsync(request, config) {
   const claimValue = payload[claim];
   return typeof claimValue === "string" && claimValue.length > 0 ? claimValue : void 0;
 }
-function resolveTenant(request, config) {
+function describeStrategies(config) {
+  const strategies = [];
   if (config.header !== void 0) {
-    const v = resolveFromHeader(request, config.header);
-    if (v !== void 0) {
-      return v;
-    }
+    strategies.push(`header '${config.header}'`);
   }
   if (config.path !== void 0) {
-    const v = resolveFromPath(request, config.path);
-    if (v !== void 0) {
-      return v;
-    }
+    const pattern = typeof config.path === "string" ? config.path : config.path.pattern;
+    strategies.push(`path '${pattern}'`);
   }
   if (config.subdomain !== void 0 && config.subdomain !== false) {
-    const v = resolveFromSubdomain(request, config.subdomain);
-    if (v !== void 0) {
-      return v;
-    }
+    strategies.push("subdomain");
   }
   if (config.jwt !== void 0) {
-    const v = resolveFromJwt(request, config.jwt);
-    if (v !== void 0) {
-      return v;
-    }
+    const claim = typeof config.jwt === "string" ? config.jwt : config.jwt.claim;
+    strategies.push(`jwt claim '${claim}'`);
   }
   if (config.custom !== void 0) {
-    const v = config.custom(request);
-    if (typeof v === "string" && v.length > 0) {
-      return v;
-    }
+    strategies.push("custom resolver");
   }
-  return void 0;
+  return strategies;
 }
-async function resolveTenantAsync(request, config) {
+async function resolveTenant(request, config) {
   if (config.header !== void 0) {
     const v = resolveFromHeader(request, config.header);
     if (v !== void 0) {
@@ -592,7 +552,7 @@ async function resolveTenantAsync(request, config) {
     }
   }
   if (config.jwt !== void 0) {
-    const v = await resolveFromJwtAsync(request, config.jwt);
+    const v = await resolveFromJwt(request, config.jwt);
     if (v !== void 0) {
       return v;
     }
@@ -606,41 +566,214 @@ async function resolveTenantAsync(request, config) {
   return void 0;
 }
 
+// src/console-endpoints.ts
+function toConsoleRequest(request) {
+  if (request && typeof request === "object") {
+    return request;
+  }
+  return {};
+}
+function parsePositiveInt(value, max) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return void 0;
+  }
+  return Math.min(Math.floor(parsed), max);
+}
+function createTenantConsoleEndpoints(api) {
+  return [
+    {
+      method: "GET",
+      path: "/tenants",
+      requiredPermission: "read",
+      async handler(request) {
+        try {
+          const { query } = toConsoleRequest(request);
+          const limit = parsePositiveInt(query?.limit, 1e3);
+          const offset = parsePositiveInt(query?.offset, Number.MAX_SAFE_INTEGER);
+          const options = {};
+          if (limit !== void 0) {
+            options.limit = limit;
+          }
+          if (offset !== void 0) {
+            options.offset = offset;
+          }
+          const tenants = await api.listTenants(options);
+          return { status: 200, body: tenants };
+        } catch (error) {
+          return { status: 500, body: { error: "Internal server error" } };
+        }
+      }
+    },
+    {
+      method: "GET",
+      path: "/tenants/:id",
+      requiredPermission: "read",
+      async handler(request) {
+        try {
+          const { params } = toConsoleRequest(request);
+          const id = params?.id?.trim();
+          if (!id) {
+            return { status: 400, body: { error: "Missing tenant id" } };
+          }
+          const tenant = await api.getTenant(id);
+          if (!tenant) {
+            return { status: 404, body: { error: "Tenant not found" } };
+          }
+          return { status: 200, body: tenant };
+        } catch {
+          return { status: 500, body: { error: "Internal server error" } };
+        }
+      }
+    },
+    {
+      method: "POST",
+      path: "/tenants",
+      requiredPermission: "write",
+      async handler(request) {
+        try {
+          const { body } = toConsoleRequest(request);
+          if (!body || typeof body !== "object") {
+            return { status: 400, body: { error: "Request body is required" } };
+          }
+          const name = typeof body.name === "string" ? body.name : "";
+          const slug = typeof body.slug === "string" ? body.slug : "";
+          if (!name.trim() || !slug.trim()) {
+            return { status: 400, body: { error: "name and slug are required" } };
+          }
+          const tenant = await api.createTenant({ name, slug });
+          return { status: 201, body: tenant };
+        } catch {
+          return { status: 500, body: { error: "Internal server error" } };
+        }
+      }
+    },
+    {
+      method: "PATCH",
+      path: "/tenants/:id",
+      requiredPermission: "write",
+      async handler(request) {
+        try {
+          const { params, body } = toConsoleRequest(request);
+          const id = params?.id?.trim();
+          if (!id) {
+            return { status: 400, body: { error: "Missing tenant id" } };
+          }
+          if (!body || typeof body !== "object") {
+            return { status: 400, body: { error: "Request body is required" } };
+          }
+          const data = {};
+          if (typeof body.name === "string") {
+            data.name = body.name;
+          }
+          if (typeof body.slug === "string") {
+            data.slug = body.slug;
+          }
+          const tenant = await api.updateTenant(id, data);
+          return { status: 200, body: tenant };
+        } catch {
+          return { status: 500, body: { error: "Internal server error" } };
+        }
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/tenants/:id",
+      requiredPermission: "admin",
+      async handler(request) {
+        try {
+          const { params } = toConsoleRequest(request);
+          const id = params?.id?.trim();
+          if (!id) {
+            return { status: 400, body: { error: "Missing tenant id" } };
+          }
+          await api.deleteTenant(id);
+          return { status: 204, body: null };
+        } catch {
+          return { status: 500, body: { error: "Internal server error" } };
+        }
+      }
+    },
+    {
+      method: "GET",
+      path: "/stats",
+      requiredPermission: "read",
+      async handler() {
+        try {
+          const tenantCount = await api.countTenants();
+          return { status: 200, body: { tenantCount } };
+        } catch (error) {
+          return { status: 500, body: { error: "Internal server error" } };
+        }
+      }
+    }
+  ];
+}
+
 // src/better-tenant.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function resolveIdentifierToId(identifier, resolverConfig, adapter, getTenantRepository) {
+  if (resolverConfig.resolveToId) {
+    return resolverConfig.resolveToId(identifier);
+  }
+  if (UUID_RE.test(identifier)) {
+    return identifier;
+  }
+  if (adapter.runAsSystem) {
+    const tenant = await adapter.runAsSystem(
+      (systemDb) => getTenantRepository(systemDb).getBySlug(identifier)
+    );
+    return tenant?.id;
+  }
+  return identifier;
+}
 function betterTenant(config) {
-  const { adapter, tenantResolver, getTenantRepository, loadTenant } = config;
+  const { database, tenantResolver, loadTenant } = config;
+  const { adapter, getTenantRepository } = database;
   sendInitTelemetry(config, config.telemetry);
-  const api = getTenantRepository ? createTenantApi(adapter, getTenantRepository) : createStubTenantApi();
-  const shouldLoadTenant = getTenantRepository != null && loadTenant !== false;
-  const runWithTenantAndDatabaseOptions = shouldLoadTenant ? { loadTenant: true, getTenantRepository } : void 0;
+  const api = createTenantApi(adapter, getTenantRepository);
+  const runWithTenantAndDatabaseOptions = loadTenant !== false ? { loadTenant: true, getTenantRepository } : void 0;
+  const resolverStrategies = describeStrategies(tenantResolver);
+  async function resolveAndNormalize(request) {
+    const raw = await resolveTenant(request, tenantResolver);
+    if (!raw) return void 0;
+    return resolveIdentifierToId(
+      raw,
+      tenantResolver,
+      adapter,
+      getTenantRepository
+    );
+  }
+  if (config.console) {
+    const endpoints = createTenantConsoleEndpoints(api);
+    config.console.registerProduct({
+      id: "tenant",
+      name: "Better Tenant",
+      endpoints
+    });
+  }
   return {
     getContext,
     getDatabase: () => getDatabase(),
     runWithTenant,
-    runWithTenantAndDatabase: (tenantId, _adapter, fn) => runWithTenantAndDatabase(tenantId, adapter, fn, runWithTenantAndDatabaseOptions),
-    runAs: (tenantId, _adapter, fn) => runAs(tenantId, adapter, fn),
+    runAs: (tenantId, fn) => runWithTenantAndDatabase(
+      tenantId,
+      adapter,
+      fn,
+      runWithTenantAndDatabaseOptions
+    ),
     runAsSystem: (fn) => runAsSystem(adapter, fn),
-    resolveTenant: (request) => resolveTenant(request, tenantResolver),
-    resolveTenantAsync: (request) => resolveTenantAsync(request, tenantResolver),
+    resolveTenant: resolveAndNormalize,
+    resolverStrategies,
     handleRequest: (request, next, options) => handleRequest(request, next, {
       ...options,
-      resolveTenant: (input) => resolveTenantAsync(input, tenantResolver),
+      resolveTenant: resolveAndNormalize,
       adapter
     }),
-    tenant: { api }
-  };
-}
-function createStubTenantApi() {
-  const err = () => {
-    throw new Error(
-      "better-tenant: tenant.api requires getTenantRepository in config"
-    );
-  };
-  return {
-    createTenant: () => err(),
-    updateTenant: () => err(),
-    listTenants: () => err(),
-    deleteTenant: () => err()
+    api
   };
 }
 
@@ -733,14 +866,13 @@ export {
   TenantNotResolvedError,
   betterTenant,
   createTenantApi,
+  describeStrategies,
   getContext,
   handleRequest,
   resolveTenant,
-  resolveTenantAsync,
   runAs,
   runAsSystem,
   runWithTenant,
-  runWithTenantAndDatabase,
   sendCliTelemetry,
   toResolvableRequest
 };