@nsp-labs/agnostic-sdk 0.1.0

package/src/lib/runtime-client.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeWorkflowRunsNamespace = exports.RuntimeWorkflowsNamespace = exports.RuntimeGatewayNamespace = exports.RuntimeJobsNamespace = exports.RuntimeEventsNamespace = exports.RuntimeDataViewTableClient = exports.RuntimeDataViewClient = exports.RuntimeDataRecordsClient = exports.RuntimeDataTableClient = exports.RuntimeDataNamespace = exports.RuntimeContextNamespace = exports.RuntimeAppAuthNamespace = exports.AgnosticRuntime = void 0;
+exports.createAgnosticRuntime = createAgnosticRuntime;
+const http_client_1 = require("./http-client");
+const context_1 = require("./context");
+const errors_1 = require("./errors");
+const APP_AUTH_VERIFY_SESSION_PATH = '/api/v1/runtime/app-auth/session/verify';
+const APP_AUTH_USER_PATH = '/api/v1/runtime/app-auth/users/{userId}';
+const AUTH_CONTEXT_PATH = '/api/v1/runtime/auth/context';
+const DATA_RECORDS_PATH = '/api/v1/runtime/data/tables/{tableName}/records';
+const DATA_RECORD_PATH = '/api/v1/runtime/data/tables/{tableName}/records/{recordId}';
+const DATA_VIEW_WINDOW_PATH = '/api/v1/runtime/data/views/{viewId}/table/window';
+const EVENTS_PATH = '/api/v1/runtime/events/{eventName}';
+const JOBS_PATH = '/api/v1/runtime/jobs/{jobName}';
+const GATEWAY_PATH = '/api/v1/runtime/gateway/{routeName}';
+const WORKFLOWS_START_PATH = '/api/v1/runtime/workflows/{workflowSlug}/runs';
+const WORKFLOW_RUN_PATH = '/api/v1/runtime/workflow-runs/{runId}';
+const WORKFLOW_RUN_STEPS_PATH = '/api/v1/runtime/workflow-runs/{runId}/steps';
+const DEFAULT_WAIT_TIMEOUT_MS = 60_000;
+const DEFAULT_WAIT_POLL_INTERVAL_MS = 1_000;
+const TERMINAL_WORKFLOW_STATUSES = new Set([
+    'succeeded',
+    'failed',
+    'cancelled',
+]);
+class AgnosticRuntime {
+    constructor(config = {}) {
+        this.runtimeContext = (0, context_1.resolveRuntimeContext)(config);
+        this.openapi = (0, http_client_1.createRuntimeOpenApiClient)({
+            actor: config.actor,
+            context: this.runtimeContext,
+            fetch: config.fetch,
+        });
+        this.auth = new RuntimeAppAuthNamespace(this.openapi);
+        this.context = new RuntimeContextNamespace(this.openapi);
+        this.data = new RuntimeDataNamespace(this.openapi);
+        this.events = new RuntimeEventsNamespace(this.openapi);
+        this.jobs = new RuntimeJobsNamespace(this.openapi);
+        this.gateway = new RuntimeGatewayNamespace(this.openapi);
+        this.workflowRuns = new RuntimeWorkflowRunsNamespace(this.openapi);
+        this.workflows = new RuntimeWorkflowsNamespace(this.openapi, this.workflowRuns);
+    }
+    getRuntimeContext() {
+        return { ...this.runtimeContext };
+    }
+}
+exports.AgnosticRuntime = AgnosticRuntime;
+class RuntimeAppAuthNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    async requireSession(request, options) {
+        const sessionToken = typeof request === 'string'
+            ? normalizeSessionToken(request)
+            : extractAppSessionToken(request);
+        if (!sessionToken) {
+            throw new errors_1.AgnosticRuntimeError({
+                status: 0,
+                code: 'app_auth_session_missing',
+                message: 'App Auth session token was not found in the request',
+                details: {
+                    accepted: ['Authorization: Bearer <token>', 'agnostic_app_session_*'],
+                },
+            });
+        }
+        const result = await this.openapi.POST(APP_AUTH_VERIFY_SESSION_PATH, {
+            body: { sessionToken },
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to verify App Auth session');
+    }
+    async getUser(userId, options) {
+        const result = await this.openapi.GET(APP_AUTH_USER_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { userId },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to load App Auth user');
+    }
+}
+exports.RuntimeAppAuthNamespace = RuntimeAppAuthNamespace;
+function createAgnosticRuntime(config = {}) {
+    return new AgnosticRuntime(config);
+}
+class RuntimeContextNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    async get(options) {
+        const result = await this.openapi.GET(AUTH_CONTEXT_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to load runtime context');
+    }
+}
+exports.RuntimeContextNamespace = RuntimeContextNamespace;
+class RuntimeDataNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    table(tableName) {
+        return new RuntimeDataTableClient(this.openapi, tableName);
+    }
+    view(viewId) {
+        return new RuntimeDataViewClient(this.openapi, viewId);
+    }
+}
+exports.RuntimeDataNamespace = RuntimeDataNamespace;
+class RuntimeDataTableClient {
+    constructor(openapi, tableName) {
+        this.tableName = tableName;
+        this.records = new RuntimeDataRecordsClient(openapi, tableName);
+    }
+}
+exports.RuntimeDataTableClient = RuntimeDataTableClient;
+class RuntimeDataRecordsClient {
+    constructor(openapi, tableName) {
+        this.openapi = openapi;
+        this.tableName = tableName;
+    }
+    async list(query = {}, options) {
+        const result = await this.openapi.GET(DATA_RECORDS_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { tableName: this.tableName },
+                query: query,
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to list data records');
+    }
+    async create(input, options) {
+        const result = await this.openapi.POST(DATA_RECORDS_PATH, {
+            body: normalizeCreateRecordInput(input),
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { tableName: this.tableName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to create data record');
+    }
+    async update(recordId, input, options) {
+        const result = await this.openapi.PATCH(DATA_RECORD_PATH, {
+            body: normalizeUpdateRecordInput(input),
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { recordId, tableName: this.tableName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to update data record');
+    }
+    async delete(recordId, options) {
+        const result = await this.openapi.DELETE(DATA_RECORD_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { recordId, tableName: this.tableName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to delete data record');
+    }
+}
+exports.RuntimeDataRecordsClient = RuntimeDataRecordsClient;
+class RuntimeDataViewClient {
+    constructor(openapi, viewId) {
+        this.table = new RuntimeDataViewTableClient(openapi, viewId);
+    }
+}
+exports.RuntimeDataViewClient = RuntimeDataViewClient;
+class RuntimeDataViewTableClient {
+    constructor(openapi, viewId) {
+        this.openapi = openapi;
+        this.viewId = viewId;
+    }
+    async window(query = {}, options) {
+        const result = await this.openapi.GET(DATA_VIEW_WINDOW_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { viewId: this.viewId },
+                query: query,
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to load data view window');
+    }
+}
+exports.RuntimeDataViewTableClient = RuntimeDataViewTableClient;
+class RuntimeEventsNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    async publish(eventName, payload = {}, options = {}) {
+        const result = await this.openapi.POST(EVENTS_PATH, {
+            body: {
+                delaySeconds: options.delaySeconds,
+                messageDeduplicationId: options.messageDeduplicationId,
+                messageGroupId: options.messageGroupId,
+                payload,
+            },
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { eventName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to publish runtime event');
+    }
+    async publishBatch(eventName, messages, options) {
+        return Promise.all(messages.map((message) => this.publish(eventName, message.payload ?? {}, {
+            ...(options ?? {}),
+            ...(message.options ?? {}),
+        })));
+    }
+}
+exports.RuntimeEventsNamespace = RuntimeEventsNamespace;
+class RuntimeJobsNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    async enqueue(jobName, payload = {}, options = {}) {
+        const result = await this.openapi.POST(JOBS_PATH, {
+            body: {
+                delaySeconds: options.delaySeconds,
+                messageDeduplicationId: options.messageDeduplicationId,
+                messageGroupId: options.messageGroupId,
+                payload,
+            },
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { jobName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to enqueue runtime job');
+    }
+}
+exports.RuntimeJobsNamespace = RuntimeJobsNamespace;
+class RuntimeGatewayNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    async call(routeName, payload = {}, options = {}) {
+        const result = await this.openapi.POST(GATEWAY_PATH, {
+            body: {
+                headers: options.headers,
+                payload,
+                query: options.query,
+            },
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { routeName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to call runtime gateway route');
+    }
+}
+exports.RuntimeGatewayNamespace = RuntimeGatewayNamespace;
+class RuntimeWorkflowsNamespace {
+    constructor(openapi, workflowRuns) {
+        this.openapi = openapi;
+        this.workflowRuns = workflowRuns;
+    }
+    async start(workflowSlug, inputPayload = {}, options) {
+        const result = await this.openapi.POST(WORKFLOWS_START_PATH, {
+            body: { inputPayload },
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { workflowSlug },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to start runtime workflow');
+    }
+    async getRun(runId, options) {
+        return this.workflowRuns.get(runId, options);
+    }
+}
+exports.RuntimeWorkflowsNamespace = RuntimeWorkflowsNamespace;
+class RuntimeWorkflowRunsNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    async get(runId, options) {
+        const result = await this.openapi.GET(WORKFLOW_RUN_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { runId },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to load workflow run');
+    }
+    async wait(runId, options = {}) {
+        const startedAt = Date.now();
+        const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_WAIT_POLL_INTERVAL_MS;
+        while (true) {
+            const run = await this.get(runId, options);
+            if (TERMINAL_WORKFLOW_STATUSES.has(run.status)) {
+                return run;
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new errors_1.AgnosticRuntimeError({
+                    status: 0,
+                    code: 'workflow_run_wait_timeout',
+                    message: `Workflow run ${runId} did not finish before timeout`,
+                    details: { runId, timeoutMs, status: run.status },
+                });
+            }
+            await sleep(pollIntervalMs);
+        }
+    }
+    async listSteps(runId, options) {
+        const result = await this.openapi.GET(WORKFLOW_RUN_STEPS_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { runId },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to list workflow run steps');
+    }
+}
+exports.RuntimeWorkflowRunsNamespace = RuntimeWorkflowRunsNamespace;
+function normalizeCreateRecordInput(input) {
+    if (isRecord(input) && isRecord(input['values'])) {
+        return input;
+    }
+    return { values: input };
+}
+function normalizeUpdateRecordInput(input) {
+    if (isRecord(input) && ('values' in input || 'remove' in input)) {
+        return input;
+    }
+    return { values: input };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function extractAppSessionToken(request) {
+    const authorization = readHeader(request.headers, 'authorization');
+    const bearerMatch = /^Bearer\s+(.+)$/i.exec(authorization ?? '');
+    if (bearerMatch) {
+        return normalizeSessionToken(bearerMatch[1]);
+    }
+    return extractAppSessionCookie(readHeader(request.headers, 'cookie'));
+}
+function extractAppSessionCookie(cookieHeader) {
+    if (!cookieHeader) {
+        return null;
+    }
+    for (const cookie of cookieHeader.split(';')) {
+        const [name, ...valueParts] = cookie.trim().split('=');
+        if (!name.startsWith('agnostic_app_session_')) {
+            continue;
+        }
+        const rawValue = valueParts.join('=');
+        return normalizeSessionToken(decodeCookieValue(rawValue));
+    }
+    return null;
+}
+function readHeader(headers, name) {
+    if (!headers) {
+        return undefined;
+    }
+    const getter = headers.get;
+    if (typeof getter === 'function') {
+        const value = getter.call(headers, name);
+        return typeof value === 'string' ? value : undefined;
+    }
+    const record = headers;
+    const lowerName = name.toLowerCase();
+    const headerKey = Object.keys(record).find((key) => key.toLowerCase() === lowerName);
+    const value = headerKey ? record[headerKey] : undefined;
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    return typeof value === 'string' ? value : undefined;
+}
+function normalizeSessionToken(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function decodeCookieValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+//# sourceMappingURL=runtime-client.js.map

package/src/lib/types.d.ts

@@ -0,0 +1,224 @@
+export type RuntimeScalar = string | number | boolean | null;
+export type RuntimeJsonValue = RuntimeScalar | RuntimeJsonValue[] | {
+    [key: string]: RuntimeJsonValue;
+};
+export type RuntimeRowValue = RuntimeScalar | RuntimeJsonValue[] | {
+    [key: string]: RuntimeJsonValue;
+} | undefined;
+export type RuntimeRowData = Record<string, RuntimeRowValue>;
+export type RuntimeActorType = 'app_user' | 'platform_user' | 'runtime' | 'system';
+export interface RuntimeActorMetadata {
+    type: RuntimeActorType;
+    id?: string;
+    tenantId?: string;
+    role?: string;
+    scopes?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeContextEnvironment {
+    AGNOSTIC_API_URL?: string;
+    AGNOSTIC_PROJECT_ID?: string;
+    AGNOSTIC_ENVIRONMENT?: string;
+    AGNOSTIC_RUNTIME_TOKEN?: string;
+}
+export interface AgnosticRuntimeConfig {
+    apiUrl?: string;
+    projectId?: string;
+    environment?: string;
+    token?: string;
+    actor?: RuntimeActorMetadata | null;
+    fetch?: typeof fetch;
+}
+export interface ResolvedRuntimeContext {
+    apiUrl: string;
+    projectId: string;
+    environment: string;
+    token: string;
+}
+export interface RuntimeRequestOptions {
+    actor?: RuntimeActorMetadata | null;
+    headers?: Record<string, string>;
+}
+export type RuntimeHeaderValue = string | string[] | undefined;
+export interface RuntimeAppAuthRequestLike {
+    headers?: Headers | Record<string, RuntimeHeaderValue> | {
+        get(name: string): string | null | undefined;
+    };
+}
+export interface RuntimeAppAuthUserClaims {
+    id: string;
+    realmId: string;
+    email: string;
+    emailVerified: boolean;
+    displayName: string | null;
+    avatarUrl: string | null;
+    status: 'active' | 'disabled' | 'suspended';
+    metadata: Record<string, unknown>;
+    scopes: string[];
+}
+export interface RuntimeAppAuthSessionClaims {
+    id: string;
+    expiresAt: string;
+    createdAt: string;
+    device: string | null;
+    ipAddress: string | null;
+}
+export interface RuntimeAppAuthCachePolicy {
+    ttlSeconds: number;
+    expiresAt: string;
+}
+export interface RuntimeAppAuthActor {
+    type: 'app_user';
+    id: string;
+    tenantId?: string;
+    role?: string;
+    scopes?: string[];
+}
+export interface RuntimeAppAuthSession {
+    user: RuntimeAppAuthUserClaims;
+    session: RuntimeAppAuthSessionClaims;
+    actor: RuntimeAppAuthActor;
+    verifiedAt: string;
+    cache: RuntimeAppAuthCachePolicy;
+}
+export interface RuntimeAppAuthUserResult {
+    user: RuntimeAppAuthUserClaims;
+    actor: RuntimeAppAuthActor;
+}
+export interface RuntimeListRecordsOptions {
+    cursor?: string;
+    filter?: Record<string, unknown>;
+    limit?: number;
+    q?: string;
+    sort?: string;
+}
+export interface RuntimeListWindowOptions {
+    cursor?: string;
+    limit?: number;
+}
+export interface RuntimeRecord {
+    id: string;
+    values: RuntimeRowData;
+}
+export interface RuntimeRecordsList {
+    records: RuntimeRecord[];
+    limit: number;
+    nextCursor: string | null;
+    hasMore: boolean;
+    loadedCount: number;
+    totalCount: number;
+}
+export interface RuntimeCreateRecordInput {
+    id?: string;
+    values: RuntimeRowData;
+}
+export interface RuntimeUpdateRecordInput {
+    values?: RuntimeRowData;
+    remove?: string[];
+}
+export interface RuntimeRecordMutation {
+    id: string;
+    record?: RuntimeRecord;
+    rowsAffected: number;
+}
+export interface RuntimeDataField {
+    name: string;
+    displayName: string;
+    type: string;
+    ydbType?: string;
+    nullable?: boolean;
+    required?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeDataViewState {
+    fieldOrder: string[];
+    hiddenFields: string[];
+    fieldWidths: Record<string, number>;
+    settings: Record<string, unknown>;
+}
+export interface RuntimeTableWindow {
+    fields: RuntimeDataField[];
+    rows: RuntimeRecord[];
+    limit: number;
+    nextCursor: string | null;
+    hasMore: boolean;
+    loadedCount: number;
+    totalCount: number;
+    viewState: RuntimeDataViewState;
+}
+export interface RuntimeQueueOptions {
+    delaySeconds?: number;
+    messageDeduplicationId?: string;
+    messageGroupId?: string;
+}
+export interface RuntimeQueuedMessage {
+    name: string;
+    queueId: string;
+    queueName: string;
+    environment: string;
+    messageId: string;
+    md5OfMessageBody?: string;
+    requestId?: string;
+}
+export interface RuntimeGatewayCallOptions extends RuntimeRequestOptions {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}
+export interface RuntimeGatewayCallResult {
+    routeName: string;
+    routePath: string;
+    status: number;
+    data: unknown;
+    headers: Record<string, string>;
+}
+export type WorkflowRunStatus = 'queued' | 'running' | 'waiting' | 'succeeded' | 'failed' | 'cancelled';
+export interface RuntimeWorkflowRun {
+    id: string;
+    workflowId: string;
+    workflowVersionId: string | null;
+    environmentId: string;
+    triggerId: string | null;
+    status: WorkflowRunStatus;
+    inputPayload: Record<string, unknown>;
+    testDefinition?: Record<string, unknown> | null;
+    actorMetadata?: RuntimeActorMetadata | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+export interface RuntimeWorkflowStepRun {
+    id: string;
+    workflowRunId: string;
+    nodeId: string;
+    parentStepRunId: string | null;
+    tokenId: string;
+    branchId: string;
+    loopId: string | null;
+    itemIndex: number | null;
+    joinKey: string | null;
+    status: string;
+    attempt: number;
+    inputRef: string | null;
+    outputRef: string | null;
+    inputSummary: Record<string, unknown> | null;
+    outputSummary: Record<string, unknown> | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    error: Record<string, unknown> | null;
+}
+export interface RuntimeWorkflowWaitOptions extends RuntimeRequestOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}
+export interface RuntimeIdentityContext {
+    tokenId: string;
+    projectId: string;
+    environment: string;
+    runtimeType: 'service' | 'worker' | 'automation';
+    serviceId?: string | null;
+    workerId?: string | null;
+    capabilities: string[];
+    actor?: RuntimeActorMetadata | null;
+}

package/src/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map