@lucern/sdk 0.3.0-alpha.0 → 0.3.0-alpha.10

package/dist/realtime/index.d.ts

@@ -1,5 +1,5 @@
 import { ConvexHttpClient } from 'convex/browser';
-import { useQuery, useMutation, useAction, useConvex, ConvexReactClient, ConvexReactClientOptions } from 'convex/react';
+import { ConvexReactClient, ConvexReactClientOptions, useAction, useMutation, useConvex, useQuery } from 'convex/react';
 export { ConvexReactClientOptions as LucernConvexReactClientOptions } from 'convex/react';
 export { platformApi, subscriptionRefs } from './refs.js';
 export { AnyApi } from 'convex/server';

package/dist/reportsClient.d.ts

@@ -4,6 +4,8 @@ import { GatewayClientConfig, PlatformGatewaySuccess } from './coreClient.js';
 import './contracts/workflow-runtime.contract.js';
 import './contracts/lens-workflow.contract.js';
 import './contracts/lens-filter.contract.js';
+import './authContext.js';
+import './contracts/auth-session.contract.js';
 
 /** Configuration for the reports client. */
 type ReportsClientConfig = GatewayClientConfig;
@@ -17,25 +19,25 @@ declare function createReportsClient(config?: ReportsClientConfig): {
     /**
      * List report templates.
      */
-    listTemplates(args?: {
+    listTemplates: (args?: {
         slug?: string;
-    }): Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
+    }) => Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
     /**
      * @deprecated Use listTemplates.
      */
-    getTemplates(args?: {
+    getTemplates: (args?: {
         slug?: string;
-    }): Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
+    }) => Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
     /**
      * List reports for a topic scope.
      */
-    listReports(input: TopicIdentifierInput, args?: {
+    listReports: (input: TopicIdentifierInput, args?: {
         summary?: boolean;
-    }): Promise<PlatformGatewaySuccess<ListResult<any, "reports">>>;
+    }) => Promise<PlatformGatewaySuccess<ListResult<any, "reports">>>;
     /**
      * Get a generated report.
      */
-    getReport(reportId: string): Promise<PlatformGatewaySuccess<ReportWithSectionsResponse>>;
+    getReport: (reportId: string) => Promise<PlatformGatewaySuccess<ReportWithSectionsResponse>>;
 };
 
 export { ReportTemplatesResponse, ReportWithSectionsResponse, type ReportsClientConfig, createReportsClient };

package/dist/reportsClient.js

@@ -1,3 +1,170 @@
+// src/authContext.ts
+var LucernSdkAuthContextError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "LucernSdkAuthContextError";
+    this.reason = reason;
+  }
+};
+function cleanString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function cleanStringList(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((value) => value.trim()).filter(
+    (value, index, list) => value.length > 0 && list.indexOf(value) === index
+  );
+}
+function requireString(value, reason, label) {
+  const normalized = cleanString(value);
+  if (!normalized) {
+    throw new LucernSdkAuthContextError(
+      reason,
+      `Canonical Lucern SDK auth context is missing ${label}.`
+    );
+  }
+  return normalized;
+}
+function requirePrincipalType(principalType) {
+  if (!principalType) {
+    throw new LucernSdkAuthContextError(
+      "principal_missing",
+      "Canonical Lucern SDK auth context is missing principalType."
+    );
+  }
+  return principalType;
+}
+function requireAuthMode(authMode) {
+  if (!authMode) {
+    throw new LucernSdkAuthContextError(
+      "principal_missing",
+      "Canonical Lucern SDK auth context is missing authMode."
+    );
+  }
+  return authMode;
+}
+function ensurePermitMatch(args) {
+  const actual = cleanString(args.actual);
+  if (actual && actual !== args.expected) {
+    throw new LucernSdkAuthContextError(
+      "policy_denied",
+      `Canonical Lucern SDK auth context has conflicting Permit ${args.field}.`
+    );
+  }
+}
+function normalizeCanonicalLucernAuthContext(input) {
+  if (!input) {
+    throw new LucernSdkAuthContextError(
+      "principal_missing",
+      "Canonical Lucern SDK auth context is required."
+    );
+  }
+  if (input.policyDecision === "deny") {
+    throw new LucernSdkAuthContextError(
+      "policy_denied",
+      "Canonical Lucern SDK auth context carries a denied policy decision."
+    );
+  }
+  const principalId = requireString(
+    input.principalId,
+    "principal_missing",
+    "principalId"
+  );
+  const tenantId = requireString(input.tenantId, "tenant_missing", "tenantId");
+  const workspaceId = requireString(
+    input.workspaceId,
+    "workspace_missing",
+    "workspaceId"
+  );
+  const roles = cleanStringList(input.roles);
+  const scopes = cleanStringList(input.scopes);
+  const principalType = requirePrincipalType(input.principalType);
+  const authMode = requireAuthMode(input.authMode);
+  const roleBasedInteractiveAuth = authMode === "interactive_user" && roles.length > 0;
+  if (roles.length === 0 || scopes.length === 0 && !roleBasedInteractiveAuth) {
+    throw new LucernSdkAuthContextError(
+      "membership_missing",
+      "Canonical Lucern SDK auth context requires non-empty roles and scopes."
+    );
+  }
+  const subject = cleanString(input.permit?.subject) ?? principalId;
+  const tenant = cleanString(input.permit?.tenant) ?? tenantId;
+  const workspace = cleanString(input.permit?.workspace) ?? workspaceId;
+  ensurePermitMatch({
+    field: "subject",
+    expected: principalId,
+    actual: subject
+  });
+  ensurePermitMatch({ field: "tenant", expected: tenantId, actual: tenant });
+  ensurePermitMatch({
+    field: "workspace",
+    expected: workspaceId,
+    actual: workspace
+  });
+  const context = input.permit?.context ? { ...input.permit.context } : void 0;
+  return {
+    clerkId: cleanString(input.clerkId),
+    principalId,
+    tenantId,
+    workspaceId,
+    principalType,
+    authMode,
+    roles,
+    scopes,
+    delegationChain: input.delegationChain ? [...input.delegationChain] : [],
+    policyTraceId: cleanString(input.policyTraceId),
+    correlationId: cleanString(input.correlationId),
+    membershipId: cleanString(input.membershipId),
+    permit: {
+      subject,
+      tenant,
+      workspace,
+      resource: cleanString(input.permit?.resource),
+      action: cleanString(input.permit?.action),
+      relation: cleanString(input.permit?.relation),
+      context
+    }
+  };
+}
+function createCanonicalAuthHeaders(authContext) {
+  const headers = {
+    "x-lucern-principal-id": authContext.principalId,
+    "x-lucern-principal-type": authContext.principalType,
+    "x-lucern-tenant": authContext.tenantId,
+    "x-lucern-tenant-id": authContext.tenantId,
+    "x-lucern-workspace": authContext.workspaceId,
+    "x-lucern-workspace-id": authContext.workspaceId,
+    "x-lucern-auth-mode": authContext.authMode,
+    "x-lucern-roles": authContext.roles.join(","),
+    "x-lucern-scopes": authContext.scopes.join(","),
+    "x-lucern-permit-context": JSON.stringify(authContext.permit)
+  };
+  if (authContext.clerkId) {
+    headers["x-lucern-clerk-id"] = authContext.clerkId;
+    headers["x-lucern-user-id"] = authContext.clerkId;
+  }
+  if (authContext.delegationChain.length > 0) {
+    headers["x-lucern-delegation-chain"] = JSON.stringify(
+      authContext.delegationChain
+    );
+  }
+  if (authContext.policyTraceId) {
+    headers["x-lucern-policy-trace-id"] = authContext.policyTraceId;
+  }
+  if (authContext.correlationId) {
+    headers["x-correlation-id"] = authContext.correlationId;
+    headers["x-lucern-correlation-id"] = authContext.correlationId;
+  }
+  if (authContext.membershipId) {
+    headers["x-lucern-membership-id"] = authContext.membershipId;
+  }
+  return headers;
+}
+
 // src/coreClient.ts
 var LucernApiError = class extends Error {
   code;
@@ -129,8 +296,11 @@ function timeoutError(timeoutMs) {
   error.name = "AbortError";
   return error;
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function readPolicySummaryFromDetails(details) {
-  if (!details || typeof details !== "object" || Array.isArray(details)) {
+  if (!isRecord(details)) {
     return null;
   }
   const directSummary = details.summary;
@@ -138,11 +308,11 @@ function readPolicySummaryFromDetails(details) {
     return directSummary.trim();
   }
   const policy = details.policy;
-  if (!policy || typeof policy !== "object" || Array.isArray(policy)) {
+  if (!isRecord(policy)) {
     return null;
   }
   const explanation = policy.explanation;
-  if (!explanation || typeof explanation !== "object" || Array.isArray(explanation)) {
+  if (!isRecord(explanation)) {
     return null;
   }
   const nestedSummary = explanation.summary;
@@ -151,16 +321,41 @@ function readPolicySummaryFromDetails(details) {
   }
   return null;
 }
+async function resolveConfiguredAuthContext(authContext) {
+  if (typeof authContext === "function") {
+    return await authContext();
+  }
+  return authContext;
+}
+function mergeHeaderRecord(base, addition) {
+  const headers = new Headers(base);
+  for (const [key, value] of Object.entries(addition)) {
+    const existing = headers.get(key);
+    if (existing !== null && existing !== value) {
+      throw new LucernSdkAuthContextError(
+        "policy_denied",
+        `Canonical Lucern SDK auth context conflicts with existing ${key} header.`
+      );
+    }
+    headers.set(key, value);
+  }
+  return Object.fromEntries(headers.entries());
+}
 function createGatewayRequestClient(config = {}) {
   const fetchImpl = config.fetchImpl ?? fetch;
   const baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "";
   const maxRetries = config.maxRetries ?? 2;
   const requestIdFactory = config.requestIdFactory ?? (() => generatePortableRequestId());
   async function resolveAuthHeaders() {
-    if (!config.getAuthHeaders) {
-      return {};
+    const base = config.getAuthHeaders ? await config.getAuthHeaders() : {};
+    const authContextInput = await resolveConfiguredAuthContext(
+      config.authContext
+    );
+    if (!authContextInput && !config.requireCanonicalAuthContext) {
+      return base;
     }
-    return await config.getAuthHeaders();
+    const authContext = normalizeCanonicalLucernAuthContext(authContextInput);
+    return mergeHeaderRecord(base, createCanonicalAuthHeaders(authContext));
   }
   async function fetchWithTimeout(url, init, timeoutMs) {
     const controller = new AbortController();
@@ -181,11 +376,11 @@ function createGatewayRequestClient(config = {}) {
     if (!text) {
       return null;
     }
-    try {
-      return JSON.parse(text);
-    } catch {
+    const parsed = tryParseGatewayEnvelopeJson(text);
+    if (!parsed.ok) {
       return null;
     }
+    return isRecord(parsed.value) ? parsed.value : null;
   }
   function resolveTimeoutMs(method, requestTimeoutMs) {
     if (typeof requestTimeoutMs === "number") {
@@ -197,16 +392,31 @@ function createGatewayRequestClient(config = {}) {
     }
     return config.timeoutMs ?? 15e3;
   }
+  function tryParseGatewayEnvelopeJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return { ok: false, reason: "non-json" };
+    }
+    try {
+      return { ok: true, value: JSON.parse(trimmed) };
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return { ok: false, reason: "invalid-json", error };
+      }
+      throw error;
+    }
+  }
   function buildApiError(args) {
     const failure = args.failure;
-    const legacyError = failure && typeof failure.error === "object" && failure.error !== null ? failure.error : failure?.legacyError;
+    const legacyError = failure && isRecord(failure.error) ? failure.error : failure?.legacyError;
     const correlationId = failure?.correlationId ?? args.response.headers.get("x-lucern-correlation-id")?.trim() ?? args.requestId;
     const policyTraceId = failure?.policyTraceId ?? args.response.headers.get("x-lucern-policy-trace-id")?.trim() ?? null;
     const details = failure?.details ?? legacyError?.details;
     const policySummary = readPolicySummaryFromDetails(details);
+    const failureMessage = typeof failure?.error === "string" ? failure.error : legacyError?.message;
     return new LucernApiError({
       code: failure?.code ?? legacyError?.code ?? fallbackErrorCode(args.response.status),
-      message: policySummary ?? (typeof failure?.error === "string" ? failure.error : legacyError?.message ?? (args.response.ok ? "Platform API returned an invalid success payload." : "Platform API request failed.")),
+      message: policySummary ?? failureMessage ?? (args.response.ok ? "Platform API returned an invalid success payload." : "Platform API request failed."),
       status: args.response.status,
       invariant: failure?.invariant,
       suggestion: failure?.suggestion,
@@ -332,11 +542,30 @@ function createGatewayRequestClient(config = {}) {
 }
 
 // src/sdkSurface.ts
-function cleanString(value) {
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord2(value) ? value : {};
+}
+function cleanString2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function resolveTopicId(value) {
-  return cleanString(value.topicId);
+  return cleanString2(value.topicId);
+}
+function asListItems(data, legacyKey) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  const record = asRecord(data);
+  if (Array.isArray(record.items)) {
+    return record.items;
+  }
+  if (Array.isArray(record[legacyKey])) {
+    return record[legacyKey];
+  }
+  return [];
 }
 function createListResult(items, legacyKey) {
   const result = {
@@ -344,7 +573,10 @@ function createListResult(items, legacyKey) {
     total: items.length
   };
   if (legacyKey) {
-    result[legacyKey] = items;
+    return {
+      ...result,
+      [legacyKey]: items
+    };
   }
   return result;
 }
@@ -358,58 +590,54 @@ function mapGatewayData(response, mapper) {
 // src/reportsClient.ts
 function createReportsClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
+  const listTemplates = async (args = {}) => gateway.request({
+    path: `/api/platform/v1/reports/templates${toQueryString({
+      slug: args.slug
+    })}`
+  }).then(
+    (response) => mapGatewayData(response, (data) => {
+      const rows = asListItems(data, "templates");
+      return createListResult(rows, "templates");
+    })
+  );
+  const listReports = async (input, args = {}) => {
+    const topicId = resolveTopicId(input);
+    if (!topicId) {
+      throw new Error("topicId is required");
+    }
+    return gateway.request({
+      path: `/api/platform/v1/reports/topics/${encodeURIComponent(topicId)}${toQueryString(
+        {
+          summary: typeof args.summary === "boolean" ? args.summary ? "true" : "false" : void 0
+        }
+      )}`
+    }).then(
+      (response) => mapGatewayData(
+        response,
+        (data) => createListResult(Array.isArray(data) ? data : [], "reports")
+      )
+    );
+  };
+  const getReport = async (reportId) => gateway.request({
+    path: `/api/platform/v1/reports/${encodeURIComponent(reportId)}`
+  });
   return {
     /**
      * List report templates.
      */
-    async listTemplates(args = {}) {
-      return gateway.request({
-        path: `/api/platform/v1/reports/templates${toQueryString({
-          slug: args.slug
-        })}`
-      }).then(
-        (response) => mapGatewayData(response, (data) => {
-          const record = data && typeof data === "object" ? data : {};
-          const rows = Array.isArray(data) ? data : Array.isArray(record.templates) ? record.templates : [];
-          return createListResult(rows, "templates");
-        })
-      );
-    },
+    listTemplates,
     /**
      * @deprecated Use listTemplates.
      */
-    async getTemplates(args = {}) {
-      return this.listTemplates(args);
-    },
+    getTemplates: listTemplates,
     /**
      * List reports for a topic scope.
      */
-    async listReports(input, args = {}) {
-      const topicId = resolveTopicId(input);
-      if (!topicId) {
-        throw new Error("topicId is required");
-      }
-      return gateway.request({
-        path: `/api/platform/v1/reports/topics/${encodeURIComponent(topicId)}${toQueryString(
-          {
-            summary: typeof args.summary === "boolean" ? args.summary ? "true" : "false" : void 0
-          }
-        )}`
-      }).then(
-        (response) => mapGatewayData(
-          response,
-          (data) => createListResult(Array.isArray(data) ? data : [], "reports")
-        )
-      );
-    },
+    listReports,
     /**
      * Get a generated report.
      */
-    async getReport(reportId) {
-      return gateway.request({
-        path: `/api/platform/v1/reports/${encodeURIComponent(reportId)}`
-      });
-    }
+    getReport
   };
 }