@usebetterdev/tenant-core 0.1.0

package/dist/index.js

@@ -0,0 +1,636 @@
+// src/telemetry.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { platform, release, arch, cpus, totalmem } from "os";
+var TELEMETRY_ENDPOINT = "https://telemetry.usebetter.dev/v1/events";
+var LIBRARY_ID = "better-tenant";
+function getTelemetryTenantConfig(config) {
+  const r = config.tenantResolver ?? {};
+  return {
+    resolver: {
+      header: !!r.header,
+      path: !!r.path,
+      subdomain: !!r.subdomain,
+      jwt: !!r.jwt,
+      custom: !!r.custom
+    },
+    tenantTablesCount: config.tenantTables?.length ?? 0,
+    hasGetTenantRepository: !!config.getTenantRepository,
+    loadTenant: config.loadTenant,
+    basePathSet: !!config.basePath,
+    plugins: (config.plugins ?? []).map((p) => String(p.id))
+  };
+}
+function getTelemetryCliConfig(config) {
+  return {
+    tenantTablesCount: config.tenantTables?.length ?? 0,
+    hasSchemaDir: !!config.schemaDir,
+    hasMigrationsDir: !!config.migrationsDir
+  };
+}
+function getAnonymousId(cwd) {
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) return void 0;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const name = typeof pkg?.name === "string" ? pkg.name : "";
+    const basePath = typeof pkg?.betterTenant?.basePath === "string" ? pkg.betterTenant.basePath : "";
+    const input = `${name}:${basePath}`.trim() || "unknown";
+    return createHash("sha256").update(input).digest("hex").slice(0, 16);
+  } catch {
+    return void 0;
+  }
+}
+function detectRuntime() {
+  const g = globalThis;
+  if (typeof g.Bun !== "undefined") {
+    const bun = g.Bun;
+    return {
+      name: "bun",
+      version: typeof bun?.version === "string" ? bun.version : "unknown"
+    };
+  }
+  if (typeof g.Deno !== "undefined") {
+    const deno = g.Deno;
+    const v2 = deno?.version?.deno;
+    return { name: "deno", version: typeof v2 === "string" ? v2 : "unknown" };
+  }
+  const v = typeof process !== "undefined" && process.versions?.node || "";
+  return { name: "node", version: v || "unknown" };
+}
+function detectEnvironment() {
+  const env = process.env.NODE_ENV || "development";
+  if (env === "test") return "test";
+  if (process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true") {
+    return "ci";
+  }
+  if (env === "production") return "production";
+  return "development";
+}
+function detectFramework(cwd) {
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) return void 0;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    if (deps["next"]) return { name: "next", version: deps["next"] };
+    if (deps["hono"]) return { name: "hono", version: deps["hono"] };
+    if (deps["express"]) return { name: "express", version: deps["express"] };
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectDatabase(cwd) {
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) return void 0;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    if (deps["drizzle-orm"])
+      return { name: "drizzle", version: deps["drizzle-orm"] };
+    if (deps["prisma"]) return { name: "prisma", version: deps["prisma"] };
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectSystem() {
+  const isDocker = existsSync("/.dockerenv");
+  const isWSL = typeof process.env.WSL_DISTRO_NAME === "string" || typeof process.env.WSL_INTEROP === "string" && process.env.WSL_INTEROP.length > 0;
+  return {
+    platform: platform(),
+    release: release(),
+    arch: arch(),
+    cpus: cpus().length,
+    totalMemoryMb: Math.round(totalmem() / 1024 / 1024),
+    isDocker,
+    isWSL
+  };
+}
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent;
+  if (!ua || typeof ua !== "string") return void 0;
+  const match = ua.match(/^(.+?)\/(\d+\.\d+\.\d+.*?)(?:\s|$)/);
+  if (match) {
+    const name = (match[1] ?? "unknown").toLowerCase();
+    const version = match[2];
+    return version ? { name, version } : { name };
+  }
+  if (ua.includes("pnpm")) return { name: "pnpm" };
+  if (ua.includes("yarn")) return { name: "yarn" };
+  return { name: "npm" };
+}
+function isTelemetryEnabled(options) {
+  if (process.env.NODE_ENV === "test") return false;
+  const env = process.env.BETTER_TENANT_TELEMETRY;
+  if (env === "0" || env?.toLowerCase() === "false") return false;
+  if (env === "1" || env?.toLowerCase() === "true") return true;
+  return options?.enabled !== false;
+}
+function isDebugMode(options) {
+  if (process.env.BETTER_TENANT_TELEMETRY_DEBUG === "1") return true;
+  return options?.debug === true;
+}
+function sendTelemetry(type, payload, options) {
+  if (!isTelemetryEnabled(options))
+    return options?.wait ? Promise.resolve() : void 0;
+  const fullPayload = {
+    library: LIBRARY_ID,
+    type,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...payload
+  };
+  if (isDebugMode(options)) {
+    console.log(
+      "[better-tenant telemetry]",
+      JSON.stringify(fullPayload, null, 2)
+    );
+    return options?.wait ? Promise.resolve() : void 0;
+  }
+  const doSend = () => fetch(TELEMETRY_ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(fullPayload)
+  }).catch(() => {
+  });
+  if (options?.wait) {
+    return new Promise((resolve) => {
+      setImmediate(async () => {
+        await doSend();
+        resolve();
+      });
+    });
+  }
+  setImmediate(() => doSend());
+}
+function sendInitTelemetry(config, options) {
+  const cwd = process.cwd();
+  const payload = {
+    runtime: detectRuntime(),
+    environment: detectEnvironment(),
+    config: getTelemetryTenantConfig(config)
+  };
+  const anonymousId = getAnonymousId(cwd);
+  if (anonymousId) payload.anonymousId = anonymousId;
+  const framework = detectFramework(cwd);
+  if (framework) payload.framework = framework;
+  const database = detectDatabase(cwd);
+  if (database) payload.database = database;
+  payload.system = detectSystem();
+  const pkgMgr = detectPackageManager();
+  if (pkgMgr) payload.packageManager = pkgMgr;
+  sendTelemetry("init", payload, options ?? config.telemetry);
+}
+function sendCliTelemetry(type, outcome, config, options) {
+  const cwd = process.cwd();
+  const redactedConfig = config ? getTelemetryCliConfig(config) : void 0;
+  const payload = {
+    runtime: detectRuntime(),
+    environment: detectEnvironment(),
+    outcome
+  };
+  if (redactedConfig) payload.config = redactedConfig;
+  payload.system = detectSystem();
+  const anonymousId = getAnonymousId(cwd);
+  if (anonymousId) payload.anonymousId = anonymousId;
+  const framework = detectFramework(cwd);
+  if (framework) payload.framework = framework;
+  const database = detectDatabase(cwd);
+  if (database) payload.database = database;
+  const pkgMgr = detectPackageManager();
+  if (pkgMgr) payload.packageManager = pkgMgr;
+  return sendTelemetry(type, payload, options);
+}
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var storage = new AsyncLocalStorage();
+function getContext() {
+  return storage.getStore();
+}
+function runWithTenant(tenantId, fn) {
+  const normalized = tenantId.trim() || void 0;
+  if (normalized === void 0) {
+    return Promise.reject(
+      new Error("better-tenant: tenantId must be a non-empty string")
+    );
+  }
+  return Promise.resolve(
+    storage.run({ tenantId: normalized }, () => fn())
+  );
+}
+function runWithContext(context, fn) {
+  return Promise.resolve(storage.run(context, () => fn()));
+}
+
+// src/adapter.ts
+function getDatabase() {
+  const context = getContext();
+  return context?.database;
+}
+async function runWithTenantAndDatabase(tenantId, adapter, fn, options) {
+  const result = await adapter.runWithTenant(tenantId, async (database) => {
+    let context = { tenantId, database };
+    if (options?.loadTenant && options.getTenantRepository && adapter.runAsSystem) {
+      const tenant = await adapter.runAsSystem(
+        (systemDb) => options.getTenantRepository(systemDb).getById(tenantId)
+      );
+      context = tenant != null ? { ...context, tenant } : context;
+    }
+    return runWithContext(context, () => fn(database));
+  });
+  return result;
+}
+
+// src/errors.ts
+var TenantNotResolvedError = class extends Error {
+  constructor(message = "better-tenant: tenant could not be resolved from request") {
+    super(message);
+    this.name = "TenantNotResolvedError";
+  }
+};
+var TenantMiddlewareError = class extends Error {
+  constructor(message = "better-tenant: failed to run tenant middleware", options) {
+    super(message, options);
+    this.name = "TenantMiddlewareError";
+  }
+};
+
+// src/handle-request.ts
+async function handleRequest(request, next, options) {
+  const tenantId = await options.resolveTenant(request);
+  const normalizedTenantId = tenantId?.trim();
+  if (!normalizedTenantId) {
+    if (options.onMissingTenant) {
+      return options.onMissingTenant(request);
+    }
+    const error = new TenantNotResolvedError();
+    if (options.onError) {
+      return options.onError(error, request);
+    }
+    throw error;
+  }
+  try {
+    return await runWithTenantAndDatabase(
+      normalizedTenantId,
+      options.adapter,
+      async () => next()
+    );
+  } catch (error) {
+    if (options.onError) {
+      return options.onError(error, request);
+    }
+    if (error instanceof TenantNotResolvedError || error instanceof TenantMiddlewareError) {
+      throw error;
+    }
+    throw new TenantMiddlewareError(void 0, { cause: error });
+  }
+}
+
+// src/api.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 50;
+function requireRunAsSystem(adapter) {
+  if (!adapter.runAsSystem) {
+    throw new Error(
+      "better-tenant: tenant.api and runAsSystem require adapter.runAsSystem; this adapter does not implement it"
+    );
+  }
+  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()) {
+        throw new Error("better-tenant: createTenant requires name");
+      }
+      if (!data.slug?.trim()) {
+        throw new Error("better-tenant: createTenant requires slug");
+      }
+      return runAsSystem2(
+        (database) => getRepository(database).create({
+          name: data.name.trim(),
+          slug: data.slug.trim()
+        })
+      );
+    },
+    async updateTenant(tenantId, data) {
+      if (!tenantId?.trim()) {
+        throw new Error("better-tenant: updateTenant requires tenantId");
+      }
+      return runAsSystem2(
+        (database) => getRepository(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 offset = Math.max(0, options.offset ?? 0);
+      return runAsSystem2(
+        (database) => getRepository(database).list({ limit, offset })
+      );
+    },
+    async deleteTenant(tenantId) {
+      if (!tenantId?.trim()) {
+        throw new Error("better-tenant: deleteTenant requires tenantId");
+      }
+      return runAsSystem2(
+        (database) => getRepository(database).delete(tenantId)
+      );
+    }
+  };
+}
+async function runAs(tenantId, adapter, fn) {
+  return runWithTenantAndDatabase(tenantId, adapter, fn);
+}
+async function runAsSystem(adapter, fn) {
+  const run = requireRunAsSystem(adapter);
+  return runWithContext(
+    { tenantId: "", isSystem: true },
+    () => run(fn)
+  );
+}
+
+// src/resolver.ts
+function getHeader(headers, name) {
+  const key = name.toLowerCase();
+  if (headers instanceof Headers) {
+    const value2 = headers.get(key);
+    return value2?.trim() || void 0;
+  }
+  const raw = headers[key] ?? headers[name];
+  if (raw === void 0) return void 0;
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  return (typeof value === "string" ? value : "").trim() || void 0;
+}
+function resolveFromHeader(request, headerName) {
+  if (!headerName) return void 0;
+  return getHeader(request.headers, headerName);
+}
+function resolveFromPath(request, pathConfig) {
+  const pathOrUrl = request.path ?? request.url;
+  if (!pathOrUrl) return void 0;
+  let path;
+  try {
+    path = pathOrUrl.startsWith("http") ? new URL(pathOrUrl).pathname : pathOrUrl;
+  } catch {
+    path = pathOrUrl;
+  }
+  const pattern = typeof pathConfig === "string" ? pathConfig : pathConfig.pattern;
+  const segmentIndex = typeof pathConfig === "object" && pathConfig.segmentIndex !== void 0 ? pathConfig.segmentIndex : parseTenantSegmentIndex(pattern);
+  const segments = path.split("/").filter(Boolean);
+  const value = segments[segmentIndex];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parseTenantSegmentIndex(pattern) {
+  const segments = pattern.split("/").filter(Boolean);
+  const idx = segments.indexOf(":tenantId");
+  return idx >= 0 ? idx : 0;
+}
+function resolveFromSubdomain(request, config) {
+  const host = request.host ?? (request.url ? new URL(request.url).host : "");
+  if (!host) return void 0;
+  const hostname = host.split(":")[0];
+  if (!hostname) return void 0;
+  const parts = hostname.split(".");
+  if (parts.length <= 2) return void 0;
+  const index = config === true ? 0 : typeof config === "object" && config.segmentIndex !== void 0 ? config.segmentIndex : 0;
+  const value = parts[index];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2) return null;
+    const payload = parts[1];
+    if (!payload) return null;
+    const decoded = atob(payload.replace(/-/g, "+").replace(/_/g, "/"));
+    return JSON.parse(decoded);
+  } catch {
+    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 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) {
+  const getToken = request.getToken;
+  if (!getToken) return void 0;
+  const token = typeof getToken === "function" ? getToken() : getToken;
+  const value = token instanceof Promise ? await token : token;
+  const resolved = value ?? void 0;
+  if (!resolved) return void 0;
+  const claim = typeof config === "string" ? config : config.claim;
+  if (!claim) return void 0;
+  const payload = decodeJwtPayload(resolved);
+  if (!payload) return void 0;
+  const claimValue = payload[claim];
+  return typeof claimValue === "string" && claimValue.length > 0 ? claimValue : void 0;
+}
+function resolveTenant(request, config) {
+  if (config.header !== void 0) {
+    const v = resolveFromHeader(request, config.header);
+    if (v !== void 0) return v;
+  }
+  if (config.path !== void 0) {
+    const v = resolveFromPath(request, config.path);
+    if (v !== void 0) return v;
+  }
+  if (config.subdomain !== void 0 && config.subdomain !== false) {
+    const v = resolveFromSubdomain(request, config.subdomain);
+    if (v !== void 0) return v;
+  }
+  if (config.jwt !== void 0) {
+    const v = resolveFromJwt(request, config.jwt);
+    if (v !== void 0) return v;
+  }
+  if (config.custom !== void 0) {
+    const v = config.custom(request);
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+async function resolveTenantAsync(request, config) {
+  if (config.header !== void 0) {
+    const v = resolveFromHeader(request, config.header);
+    if (v !== void 0) return v;
+  }
+  if (config.path !== void 0) {
+    const v = resolveFromPath(request, config.path);
+    if (v !== void 0) return v;
+  }
+  if (config.subdomain !== void 0 && config.subdomain !== false) {
+    const v = resolveFromSubdomain(request, config.subdomain);
+    if (v !== void 0) return v;
+  }
+  if (config.jwt !== void 0) {
+    const v = await resolveFromJwtAsync(request, config.jwt);
+    if (v !== void 0) return v;
+  }
+  if (config.custom !== void 0) {
+    const v = await Promise.resolve(config.custom(request));
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+
+// src/better-tenant.ts
+function betterTenant(config) {
+  const { adapter, tenantResolver, getTenantRepository, loadTenant } = config;
+  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;
+  return {
+    getContext,
+    getDatabase,
+    runWithTenant,
+    runWithTenantAndDatabase: (tenantId, _adapter, fn) => runWithTenantAndDatabase(tenantId, adapter, fn, runWithTenantAndDatabaseOptions),
+    runAs: (tenantId, _adapter, fn) => runAs(tenantId, adapter, fn),
+    runAsSystem: (fn) => runAsSystem(adapter, fn),
+    resolveTenant: (request) => resolveTenant(request, tenantResolver),
+    resolveTenantAsync: (request) => resolveTenantAsync(request, tenantResolver),
+    handleRequest: (request, next, options) => handleRequest(request, next, {
+      ...options,
+      resolveTenant: (input) => resolveTenantAsync(input, tenantResolver),
+      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()
+  };
+}
+
+// src/request.ts
+function isFetchRequest(input) {
+  return typeof Request !== "undefined" && input instanceof Request;
+}
+function normalizeHost(raw) {
+  if (!raw) return void 0;
+  const value = raw.split(":")[0]?.trim();
+  return value || void 0;
+}
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const normalizedKey = key.toLowerCase();
+    if (Array.isArray(value)) {
+      normalized[normalizedKey] = value.map((part) => String(part));
+      continue;
+    }
+    if (value === void 0) {
+      normalized[normalizedKey] = void 0;
+      continue;
+    }
+    normalized[normalizedKey] = String(value);
+  }
+  return normalized;
+}
+function pathWithoutQuery(value) {
+  if (!value) return void 0;
+  const [pathname] = value.split("?");
+  return pathname || void 0;
+}
+function toResolvableRequest(request) {
+  if (isFetchRequest(request)) {
+    const url = request.url;
+    let host2;
+    let path2;
+    try {
+      const parsedUrl = new URL(url);
+      host2 = normalizeHost(parsedUrl.host);
+      path2 = parsedUrl.pathname || void 0;
+    } catch {
+      host2 = void 0;
+      path2 = void 0;
+    }
+    const resolved2 = {
+      headers: request.headers,
+      url,
+      method: request.method
+    };
+    if (path2 !== void 0) {
+      resolved2.path = path2;
+    }
+    if (host2 !== void 0) {
+      resolved2.host = host2;
+    }
+    return resolved2;
+  }
+  const headers = normalizeHeaders(request.headers);
+  const hostFromHeaders = headers.host;
+  const hostValue = Array.isArray(hostFromHeaders) ? hostFromHeaders[0] : hostFromHeaders;
+  const host = normalizeHost(request.hostname ?? request.host ?? hostValue);
+  const path = pathWithoutQuery(request.path ?? request.originalUrl ?? request.url);
+  const resolved = {
+    headers
+  };
+  if (path !== void 0) {
+    resolved.path = path;
+  }
+  if (host !== void 0) {
+    resolved.host = host;
+  }
+  if (request.method !== void 0) {
+    resolved.method = request.method;
+  }
+  return resolved;
+}
+export {
+  TenantMiddlewareError,
+  TenantNotResolvedError,
+  betterTenant,
+  createTenantApi,
+  getContext,
+  getDatabase,
+  handleRequest,
+  resolveTenant,
+  resolveTenantAsync,
+  runAs,
+  runAsSystem,
+  runWithTenant,
+  runWithTenantAndDatabase,
+  sendCliTelemetry,
+  toResolvableRequest
+};
+//# sourceMappingURL=index.js.map