@opengeni/api-router 0.26.1 → 0.30.0

package/dist/controller-data-plane.d.ts

@@ -0,0 +1,12 @@
+/** Prefer a lease-fenced controller endpoint for the idempotent create path.
+ * Only a transport-class failure invalidates the cache and provisions once;
+ * semantic failures belong to the caller and must never be replayed. */
+export declare function withCachedController<C, T>(options: {
+    cachedUrl: string | null;
+    createCachedClient: (url: string) => C;
+    prepareCachedClient?: (client: C) => Promise<void>;
+    invalidateCachedUrl: () => Promise<unknown>;
+    provisionClient: () => Promise<C>;
+    use: (client: C) => Promise<T>;
+}): Promise<T>;
+export declare function isRetryableControllerTransport(error: unknown): boolean;

package/dist/http/auth.d.ts

@@ -1,3 +1,3 @@
-import type { Settings } from "@opengeni/config";
+import { type Settings } from "@opengeni/config";
 import type { MiddlewareHandler } from "hono";
 export declare function requireAccessKey(settings: Settings): MiddlewareHandler;

package/dist/http/sse.d.ts

@@ -1,4 +1,4 @@
-import type { SessionEvent } from "@opengeni/contracts";
+import { type SessionEvent } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 import type { Observability } from "@opengeni/observability";
@@ -58,6 +58,23 @@ export declare function createLatestWinsDelivery<T extends {
 export declare function sseSessionStream(db: Database, bus: EventBus, workspaceId: string, sessionId: string, after: number, signal: AbortSignal, options?: SessionSseDeliveryOptions): Promise<Response>;
 export declare function replaySessionEvents(loadPage: (after: number, limit: number) => Promise<SessionEvent[]>, send: (event: SessionEvent) => Promise<void>, after: number, pageSize?: number): Promise<void>;
 export declare function sseWorkspaceControlStream(db: Database, bus: EventBus, workspaceId: string, after: number, signal: AbortSignal, options?: SseDeliveryOptions): Promise<Response>;
+export type WorkspaceInteractionSseOptions = SseDeliveryOptions & {
+    pollIntervalMs?: number | undefined;
+};
+/**
+ * One HTTP connection for the two workspace-wide invalidation domains used by
+ * every visible OpenGeni surface. Keeping these as separate HTTP/1 streams
+ * consumes all six per-origin browser connections with only two windows and
+ * starves ordinary mutations/terminal grants. The durable cursors remain
+ * independent; this function only multiplexes their already-bounded SSE frames.
+ */
+export declare function sseWorkspaceLiveStream(db: Database, bus: EventBus, accountId: string, workspaceId: string, controlAfter: number, interactionAfter: number, signal: AbortSignal, options?: WorkspaceInteractionSseOptions): Promise<Response>;
+/**
+ * Latest-wins interaction invalidation stream. The durable truth is one
+ * monotonic workspace row, not an ever-growing event log. Each poll reads only
+ * that row; reconnect immediately projects the newest revision after `after`.
+ */
+export declare function sseWorkspaceInteractionRevisionStream(db: Database, accountId: string, workspaceId: string, after: number, signal: AbortSignal, options?: WorkspaceInteractionSseOptions): Promise<Response>;
 export type SseDeliveryOptions = {
     maxQueuedBytes?: number;
     stallTimeoutMs?: number;

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   createOpenGeniSlackBotInteractionClient,
   startSlackInteractionPump,
   startTemporalScheduleCleanupPump
-} from "./chunk-JIKNR5YL.js";
+} from "./chunk-2PQMSRCB.js";
 
 // src/index.ts
 import {

package/dist/integrations/api-integrations.d.ts

@@ -1,5 +1,5 @@
 import { type IntegrationCredentialResolver, type IntegrationInvocationAuthority, type IntegrationTransport } from "@opengeni/capabilities";
-import { ApiIntegrationPreview, type ApiIntegrationSource } from "@opengeni/contracts";
+import { ApiIntegrationPreview, type IntegrationSource } from "@opengeni/contracts";
 import type { StoredApiIntegrationRevision } from "@opengeni/db";
 export type ApiIntegrationConnectionDescriptor = {
     id: string;
@@ -16,7 +16,7 @@ export type ResolvedApiIntegrationPreview = {
     authScheme: Record<string, unknown>;
 };
 export declare function resolveApiIntegrationPreview(input: {
-    source: ApiIntegrationSource;
+    source: IntegrationSource;
     connection: ApiIntegrationConnectionDescriptor | null;
     transport: IntegrationTransport;
     credentialResolver?: IntegrationCredentialResolver;

package/dist/integrations/fiken.d.ts

@@ -0,0 +1,233 @@
+import type { ApiRouteDeps } from "@opengeni/core";
+import type { Settings } from "@opengeni/config";
+import { FikenOAuthStartResponse, type AccessGrant, type ConnectionMetadata, type FikenCompanySummary, type FikenConnectionMetadata, type FikenOAuthStartRequest } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+import { type FetchLike } from "@opengeni/network";
+import { HTTPException } from "hono/http-exception";
+export type FikenOperation = "companies.list" | "contacts.list" | "contact.create" | "products.list" | "invoices.list" | "invoice.get" | "invoice_draft.create" | "bank_accounts.list" | "purchases.list" | "sales.list";
+export declare class FikenProviderError extends Error {
+    readonly code: string;
+    readonly status: number | null;
+    constructor(code: string, status?: number | null, providerMessage?: string | null);
+}
+export declare class FikenCredentialVerificationError extends HTTPException {
+    constructor(message: string);
+}
+export type FikenPage = {
+    page: number;
+    pageSize: number;
+    pageCount: number | null;
+    resultCount: number | null;
+};
+type FikenContext = {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    sessionId: string | null;
+};
+/**
+ * Validates a pasted Fiken personal API token before it enters encrypted
+ * storage, and discovers the companies it can act on. The companies list is
+ * the connection's bounded metadata; company slugs are re-validated by Fiken
+ * itself on every later call.
+ */
+export declare function verifyFikenApiToken(token: string, fetchImpl?: FetchLike): Promise<{
+    companies: FikenCompanySummary[];
+}>;
+export declare function fikenCredentialBundle(token: string): Record<string, unknown>;
+export declare function resolveFikenConnectionForTool(input: {
+    db: Database;
+    grant: AccessGrant;
+    sessionId: string | null;
+    requestedConnectionId?: string;
+}): Promise<{
+    connection: ConnectionMetadata;
+    metadata: FikenConnectionMetadata;
+    context: FikenContext;
+}>;
+export type FikenListInput = {
+    companySlug?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+};
+export declare class FikenClient {
+    private readonly db;
+    private readonly settings;
+    private readonly connection;
+    private readonly metadata;
+    private readonly context;
+    private readonly fetchImpl;
+    private readonly resolveCredential;
+    constructor(db: Database, settings: Settings, connection: ConnectionMetadata, metadata: FikenConnectionMetadata, context: FikenContext, fetchImpl?: FetchLike);
+    listCompanies(input?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        companies: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    listContacts(input: FikenListInput & {
+        name?: string | undefined;
+        email?: string | undefined;
+        organizationNumber?: string | undefined;
+        customer?: boolean | undefined;
+        supplier?: boolean | undefined;
+        inactive?: boolean | undefined;
+    }): Promise<{
+        companySlug: string;
+        contacts: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    createContact(input: {
+        companySlug?: string | undefined;
+        name: string;
+        email?: string | undefined;
+        organizationNumber?: string | undefined;
+        phoneNumber?: string | undefined;
+        customer?: boolean | undefined;
+        supplier?: boolean | undefined;
+    }): Promise<{
+        companySlug: string;
+        contactId: number;
+        receipt: {
+            credentialRole: "fiken_api_token";
+            credentialLabel: "Fiken API token";
+            connectionId: string;
+            operation: FikenOperation;
+            operationId?: string;
+        };
+    }>;
+    listProducts(input: FikenListInput & {
+        name?: string | undefined;
+        active?: boolean | undefined;
+    }): Promise<{
+        companySlug: string;
+        products: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    listInvoices(input: FikenListInput & {
+        issueDateGe?: string | undefined;
+        issueDateLe?: string | undefined;
+        customerId?: number | undefined;
+        settled?: boolean | undefined;
+        invoiceNumber?: string | undefined;
+    }): Promise<{
+        companySlug: string;
+        invoices: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    getInvoice(input: {
+        companySlug?: string | undefined;
+        invoiceId: number;
+    }): Promise<{
+        companySlug: string;
+        invoice: Record<string, unknown> | null;
+    }>;
+    createInvoiceDraft(input: {
+        companySlug?: string | undefined;
+        operationId: string;
+        customerId: number;
+        daysUntilDueDate: number;
+        invoiceText?: string | undefined;
+        yourReference?: string | undefined;
+        ourReference?: string | undefined;
+        currency?: string | undefined;
+        bankAccountNumber?: string | undefined;
+        lines: Array<{
+            description?: string | undefined;
+            productId?: number | undefined;
+            unitPriceCents?: number | undefined;
+            vatType?: string | undefined;
+            quantity: number;
+            discountPercent?: number | undefined;
+            incomeAccount?: string | undefined;
+            comment?: string | undefined;
+        }>;
+    }): Promise<{
+        companySlug: string;
+        draftId: number | null;
+        draft: Record<string, unknown>;
+        alreadyExisted: boolean;
+        receipt: {
+            credentialRole: "fiken_api_token";
+            credentialLabel: "Fiken API token";
+            connectionId: string;
+            operation: FikenOperation;
+            operationId?: string;
+        };
+    } | {
+        draft?: never;
+        companySlug: string;
+        draftId: number;
+        alreadyExisted: boolean;
+        receipt: {
+            credentialRole: "fiken_api_token";
+            credentialLabel: "Fiken API token";
+            connectionId: string;
+            operation: FikenOperation;
+            operationId?: string;
+        };
+    }>;
+    listBankAccounts(input: FikenListInput & {
+        inactive?: boolean | undefined;
+    }): Promise<{
+        companySlug: string;
+        bankAccounts: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    listPurchases(input: FikenListInput & {
+        dateGe?: string | undefined;
+        dateLe?: string | undefined;
+        paid?: boolean | undefined;
+    }): Promise<{
+        companySlug: string;
+        purchases: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    listSales(input: FikenListInput & {
+        dateGe?: string | undefined;
+        dateLe?: string | undefined;
+        settled?: boolean | undefined;
+    }): Promise<{
+        companySlug: string;
+        sales: Record<string, unknown>[];
+        page: FikenPage | null;
+    }>;
+    /**
+     * The company scope for a call: an explicit slug wins, then the connection's
+     * configured default, then the only verified company. Ambiguity is an error
+     * that lists the available slugs instead of guessing.
+     */
+    private companySlugFor;
+    private request;
+    private readResponse;
+    private markNeedsReauth;
+    private headersFor;
+    private receipt;
+    private recordAudit;
+}
+export declare function createFikenClient(deps: {
+    db: Database;
+    settings: Settings;
+    fikenFetch?: typeof fetch;
+}, resolved: Awaited<ReturnType<typeof resolveFikenConnectionForTool>>): FikenClient;
+export declare class FikenOAuthCallbackError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare function startFikenOAuth(deps: ApiRouteDeps, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    requestUrl: string;
+    payload: FikenOAuthStartRequest;
+}): Promise<FikenOAuthStartResponse>;
+export declare function completeFikenOAuthCallback(deps: ApiRouteDeps, input: {
+    code?: string | undefined;
+    state?: string | undefined;
+    error?: string | undefined;
+    requestUrl: string;
+}): Promise<{
+    redirectTo: string;
+}>;
+export {};

package/dist/integrations/google-drive.d.ts

@@ -1,6 +1,6 @@
 import type { AccessGrant, ScheduledTask } from "@opengeni/contracts";
 import { GoogleDriveOAuthStartResponse, type GoogleDriveDisconnectRequest, type GoogleDriveLifecycleActionRequest, type GoogleDriveOAuthStartRequest } from "@opengeni/contracts/google-drive";
-import { IntegrationFeatureMutationResult } from "@opengeni/contracts";
+import { IntegrationFacetMutationResult } from "@opengeni/contracts";
 import type { ApiRouteDeps } from "@opengeni/core";
 import { getConnectionMetadata } from "@opengeni/db";
 export declare function wakeGoogleDriveSourcesFromWorkspaceEvent(deps: ApiRouteDeps, input: {
@@ -95,12 +95,12 @@ export declare function browseGoogleDrive(deps: ApiRouteDeps, input: {
     nextPageToken: string | null;
     incompleteSearch: boolean;
 }>;
-export declare function browseGoogleDriveIntegrationSource(deps: ApiRouteDeps, input: {
+export declare function browseGoogleDriveFacetSource(deps: ApiRouteDeps, input: {
     workspaceId: string;
     subjectId: string;
     capabilityId: string;
     instanceKey: string;
-    featureKey: string;
+    facetKey: string;
     parentId: string;
     pageToken?: string | undefined;
 }): Promise<{
@@ -150,18 +150,18 @@ export declare function browseGoogleDriveIntegrationSource(deps: ApiRouteDeps, i
     nextPageToken: string | null;
     incompleteSearch: boolean;
 }>;
-export declare function saveGoogleDriveIntegrationSource(deps: ApiRouteDeps, input: {
+export declare function saveGoogleDriveFacetSource(deps: ApiRouteDeps, input: {
     accountId: string;
     workspaceId: string;
     subjectId: string;
     capabilityId: string;
     instanceKey: string;
-    featureKey: string;
+    facetKey: string;
     payload: unknown;
     canManageOrganizationDestination: boolean;
     canManageWorkspaceDestination: boolean;
     canManagePersonalDestination: boolean;
-}): Promise<IntegrationFeatureMutationResult>;
+}): Promise<IntegrationFacetMutationResult>;
 export declare function saveGoogleDriveSource(deps: ApiRouteDeps, input: {
     accountId: string;
     workspaceId: string;

package/dist/integrations/provider-oauth.d.ts

@@ -1,4 +1,3 @@
-import { type Settings } from "@opengeni/config";
 import { OAuthStartResponse, type ApiIntegrationOAuthStartRequest } from "@opengeni/contracts";
 import { type ApiRouteDeps } from "@opengeni/core";
 export declare function startApiIntegrationProviderOAuth(deps: ApiRouteDeps, input: {
@@ -16,4 +15,3 @@ export declare function completeApiIntegrationProviderOAuth(deps: ApiRouteDeps,
 }): Promise<{
     redirectTo: string;
 }>;
-export declare function isApiIntegrationProviderOAuthState(value: string | undefined, settings: Settings): boolean;