@nsp-labs/agnostic-sdk 0.1.0

package/src/generated/openapi.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=openapi.js.map

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export { AgnosticRuntime, RuntimeAppAuthNamespace, RuntimeContextNamespace, RuntimeDataNamespace, RuntimeDataRecordsClient, RuntimeDataTableClient, RuntimeDataViewClient, RuntimeDataViewTableClient, RuntimeEventsNamespace, RuntimeGatewayNamespace, RuntimeJobsNamespace, RuntimeWorkflowRunsNamespace, RuntimeWorkflowsNamespace, createAgnosticRuntime, } from './lib/runtime-client';
+export { normalizeApiUrl, resolveRuntimeContext } from './lib/context';
+export { AgnosticRuntimeError } from './lib/errors';
+export type { AgnosticRuntimeConfig, ResolvedRuntimeContext, RuntimeActorMetadata, RuntimeActorType, RuntimeAppAuthActor, RuntimeAppAuthCachePolicy, RuntimeAppAuthRequestLike, RuntimeAppAuthSession, RuntimeAppAuthSessionClaims, RuntimeAppAuthUserClaims, RuntimeAppAuthUserResult, RuntimeCreateRecordInput, RuntimeDataField, RuntimeDataViewState, RuntimeGatewayCallOptions, RuntimeGatewayCallResult, RuntimeIdentityContext, RuntimeListRecordsOptions, RuntimeListWindowOptions, RuntimeQueuedMessage, RuntimeQueueOptions, RuntimeRecord, RuntimeRecordMutation, RuntimeRecordsList, RuntimeRequestOptions, RuntimeRowData, RuntimeRowValue, RuntimeTableWindow, RuntimeUpdateRecordInput, RuntimeWorkflowRun, RuntimeWorkflowStepRun, RuntimeWorkflowWaitOptions, WorkflowRunStatus, } from './lib/types';

package/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnosticRuntimeError = exports.resolveRuntimeContext = exports.normalizeApiUrl = exports.createAgnosticRuntime = exports.RuntimeWorkflowsNamespace = exports.RuntimeWorkflowRunsNamespace = exports.RuntimeJobsNamespace = exports.RuntimeGatewayNamespace = exports.RuntimeEventsNamespace = exports.RuntimeDataViewTableClient = exports.RuntimeDataViewClient = exports.RuntimeDataTableClient = exports.RuntimeDataRecordsClient = exports.RuntimeDataNamespace = exports.RuntimeContextNamespace = exports.RuntimeAppAuthNamespace = exports.AgnosticRuntime = void 0;
+var runtime_client_1 = require("./lib/runtime-client");
+Object.defineProperty(exports, "AgnosticRuntime", { enumerable: true, get: function () { return runtime_client_1.AgnosticRuntime; } });
+Object.defineProperty(exports, "RuntimeAppAuthNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeAppAuthNamespace; } });
+Object.defineProperty(exports, "RuntimeContextNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeContextNamespace; } });
+Object.defineProperty(exports, "RuntimeDataNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataNamespace; } });
+Object.defineProperty(exports, "RuntimeDataRecordsClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataRecordsClient; } });
+Object.defineProperty(exports, "RuntimeDataTableClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataTableClient; } });
+Object.defineProperty(exports, "RuntimeDataViewClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataViewClient; } });
+Object.defineProperty(exports, "RuntimeDataViewTableClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataViewTableClient; } });
+Object.defineProperty(exports, "RuntimeEventsNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeEventsNamespace; } });
+Object.defineProperty(exports, "RuntimeGatewayNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeGatewayNamespace; } });
+Object.defineProperty(exports, "RuntimeJobsNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeJobsNamespace; } });
+Object.defineProperty(exports, "RuntimeWorkflowRunsNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeWorkflowRunsNamespace; } });
+Object.defineProperty(exports, "RuntimeWorkflowsNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeWorkflowsNamespace; } });
+Object.defineProperty(exports, "createAgnosticRuntime", { enumerable: true, get: function () { return runtime_client_1.createAgnosticRuntime; } });
+var context_1 = require("./lib/context");
+Object.defineProperty(exports, "normalizeApiUrl", { enumerable: true, get: function () { return context_1.normalizeApiUrl; } });
+Object.defineProperty(exports, "resolveRuntimeContext", { enumerable: true, get: function () { return context_1.resolveRuntimeContext; } });
+var errors_1 = require("./lib/errors");
+Object.defineProperty(exports, "AgnosticRuntimeError", { enumerable: true, get: function () { return errors_1.AgnosticRuntimeError; } });
+//# sourceMappingURL=index.js.map

package/src/lib/context.d.ts

@@ -0,0 +1,3 @@
+import type { AgnosticRuntimeConfig, ResolvedRuntimeContext, RuntimeContextEnvironment } from './types';
+export declare function resolveRuntimeContext(config?: AgnosticRuntimeConfig, env?: RuntimeContextEnvironment): ResolvedRuntimeContext;
+export declare function normalizeApiUrl(value: string): string;

package/src/lib/context.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeContext = resolveRuntimeContext;
+exports.normalizeApiUrl = normalizeApiUrl;
+const errors_1 = require("./errors");
+const CONTEXT_FIELDS = {
+    apiUrl: 'AGNOSTIC_API_URL',
+    projectId: 'AGNOSTIC_PROJECT_ID',
+    environment: 'AGNOSTIC_ENVIRONMENT',
+    token: 'AGNOSTIC_RUNTIME_TOKEN',
+};
+function resolveRuntimeContext(config = {}, env = readRuntimeEnvironment()) {
+    const rawContext = {
+        apiUrl: firstNonEmpty(config.apiUrl, env.AGNOSTIC_API_URL),
+        projectId: firstNonEmpty(config.projectId, env.AGNOSTIC_PROJECT_ID),
+        environment: firstNonEmpty(config.environment, env.AGNOSTIC_ENVIRONMENT),
+        token: firstNonEmpty(config.token, env.AGNOSTIC_RUNTIME_TOKEN),
+    };
+    const missing = Object.entries(rawContext)
+        .filter(([, value]) => !value)
+        .map(([field]) => field);
+    if (missing.length > 0) {
+        throw new errors_1.AgnosticRuntimeError({
+            status: 0,
+            code: 'runtime_context_missing',
+            message: `Missing Agnostic runtime context: ${missing.join(', ')}`,
+            details: {
+                missing,
+                env: missing.map((field) => CONTEXT_FIELDS[field]),
+            },
+        });
+    }
+    return {
+        apiUrl: normalizeApiUrl(rawContext.apiUrl),
+        projectId: rawContext.projectId,
+        environment: rawContext.environment,
+        token: rawContext.token,
+    };
+}
+function normalizeApiUrl(value) {
+    const url = new URL(value.trim());
+    url.pathname = url.pathname.replace(/\/+$/, '') || '/';
+    url.search = '';
+    url.hash = '';
+    let normalized = url.toString().replace(/\/$/, '');
+    if (normalized.endsWith('/api/v1')) {
+        normalized = normalized.slice(0, -7);
+    }
+    else if (normalized.endsWith('/api')) {
+        normalized = normalized.slice(0, -4);
+    }
+    return normalized;
+}
+function firstNonEmpty(...values) {
+    return values
+        .find((value) => typeof value === 'string' && value.trim())
+        ?.trim();
+}
+function readRuntimeEnvironment() {
+    if (typeof process === 'undefined' || !process.env) {
+        return {};
+    }
+    return {
+        AGNOSTIC_API_URL: process.env['AGNOSTIC_API_URL'],
+        AGNOSTIC_ENVIRONMENT: process.env['AGNOSTIC_ENVIRONMENT'],
+        AGNOSTIC_PROJECT_ID: process.env['AGNOSTIC_PROJECT_ID'],
+        AGNOSTIC_RUNTIME_TOKEN: process.env['AGNOSTIC_RUNTIME_TOKEN'],
+    };
+}
+//# sourceMappingURL=context.js.map

package/src/lib/errors.d.ts

@@ -0,0 +1,14 @@
+export interface AgnosticRuntimeErrorOptions {
+    status?: number;
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export declare class AgnosticRuntimeError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(options: AgnosticRuntimeErrorOptions);
+}
+export declare function toRuntimeError(response: Response, payload: unknown, fallbackMessage: string): AgnosticRuntimeError;
+export declare function toNetworkError(error: unknown): AgnosticRuntimeError;

package/src/lib/errors.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnosticRuntimeError = void 0;
+exports.toRuntimeError = toRuntimeError;
+exports.toNetworkError = toNetworkError;
+class AgnosticRuntimeError extends Error {
+    constructor(options) {
+        super(options.message);
+        this.name = 'AgnosticRuntimeError';
+        this.status = options.status ?? 0;
+        this.code = options.code;
+        this.details = options.details;
+    }
+}
+exports.AgnosticRuntimeError = AgnosticRuntimeError;
+function toRuntimeError(response, payload, fallbackMessage) {
+    const message = readString(payload, 'message') ?? fallbackMessage;
+    const explicitCode = readString(payload, 'code');
+    const errorName = readString(payload, 'error');
+    return new AgnosticRuntimeError({
+        status: response.status,
+        code: explicitCode ??
+            normalizeErrorCode(errorName) ??
+            `http_${response.status}`,
+        message,
+        details: payload,
+    });
+}
+function toNetworkError(error) {
+    return new AgnosticRuntimeError({
+        status: 0,
+        code: 'network_error',
+        message: error instanceof Error && error.message
+            ? error.message
+            : 'Network request failed',
+        details: error,
+    });
+}
+function normalizeErrorCode(value) {
+    if (!value) {
+        return undefined;
+    }
+    return value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[^a-zA-Z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase();
+}
+function readString(payload, key) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return undefined;
+    }
+    const value = payload[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+//# sourceMappingURL=errors.js.map

package/src/lib/http-client.d.ts

@@ -0,0 +1,18 @@
+import { type Client } from 'openapi-fetch';
+import type { paths } from '../generated/openapi';
+import type { ResolvedRuntimeContext, RuntimeActorMetadata, RuntimeRequestOptions } from './types';
+export declare const RUNTIME_ACTOR_HEADER = "x-agnostic-actor";
+export type RuntimeOpenApiClient = Client<paths>;
+export interface RuntimeApiResult {
+    data?: unknown;
+    error?: unknown;
+    response: Response;
+}
+export declare function createRuntimeOpenApiClient(options: {
+    actor?: RuntimeActorMetadata | null;
+    context: ResolvedRuntimeContext;
+    fetch?: typeof fetch;
+}): RuntimeOpenApiClient;
+export declare function runtimeRequestHeaders(options?: RuntimeRequestOptions): Record<string, string> | undefined;
+export declare function unwrapRuntimeResult<T>(result: RuntimeApiResult, fallbackMessage: string): T;
+export declare function unwrapApiEnvelope(payload: unknown): unknown;

package/src/lib/http-client.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_ACTOR_HEADER = void 0;
+exports.createRuntimeOpenApiClient = createRuntimeOpenApiClient;
+exports.runtimeRequestHeaders = runtimeRequestHeaders;
+exports.unwrapRuntimeResult = unwrapRuntimeResult;
+exports.unwrapApiEnvelope = unwrapApiEnvelope;
+const tslib_1 = require("tslib");
+const openapi_fetch_1 = tslib_1.__importDefault(require("openapi-fetch"));
+const errors_1 = require("./errors");
+exports.RUNTIME_ACTOR_HEADER = 'x-agnostic-actor';
+function createRuntimeOpenApiClient(options) {
+    const openapi = (0, openapi_fetch_1.default)({
+        baseUrl: options.context.apiUrl,
+        fetch: options.fetch,
+    });
+    openapi.use({
+        onRequest({ request }) {
+            request.headers.set('Accept', 'application/json');
+            request.headers.set('Authorization', `Bearer ${options.context.token}`);
+            if (options.actor) {
+                request.headers.set(exports.RUNTIME_ACTOR_HEADER, JSON.stringify(options.actor));
+            }
+            return request;
+        },
+        onError({ error }) {
+            return (0, errors_1.toNetworkError)(error);
+        },
+    });
+    return openapi;
+}
+function runtimeRequestHeaders(options) {
+    const headers = { ...(options?.headers ?? {}) };
+    if (options && 'actor' in options) {
+        if (options.actor) {
+            headers[exports.RUNTIME_ACTOR_HEADER] = JSON.stringify(options.actor);
+        }
+        else {
+            delete headers[exports.RUNTIME_ACTOR_HEADER];
+        }
+    }
+    return Object.keys(headers).length > 0 ? headers : undefined;
+}
+function unwrapRuntimeResult(result, fallbackMessage) {
+    const payload = result.response.ok
+        ? result.data
+        : (result.error ?? result.data);
+    if (!result.response.ok) {
+        throw (0, errors_1.toRuntimeError)(result.response, payload, fallbackMessage);
+    }
+    return unwrapApiEnvelope(payload);
+}
+function unwrapApiEnvelope(payload) {
+    if (!isPlainObject(payload)) {
+        return payload;
+    }
+    if ('data' in payload && ('success' in payload || 'message' in payload)) {
+        return payload['data'];
+    }
+    return payload;
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=http-client.js.map

package/src/lib/runtime-client.d.ts

@@ -0,0 +1,91 @@
+import { type RuntimeOpenApiClient } from './http-client';
+import type { AgnosticRuntimeConfig, ResolvedRuntimeContext, RuntimeAppAuthRequestLike, RuntimeAppAuthSession, RuntimeAppAuthUserResult, RuntimeCreateRecordInput, RuntimeGatewayCallOptions, RuntimeGatewayCallResult, RuntimeIdentityContext, RuntimeListRecordsOptions, RuntimeListWindowOptions, RuntimeQueuedMessage, RuntimeQueueOptions, RuntimeRecordMutation, RuntimeRecordsList, RuntimeRequestOptions, RuntimeRowData, RuntimeTableWindow, RuntimeUpdateRecordInput, RuntimeWorkflowRun, RuntimeWorkflowStepRun, RuntimeWorkflowWaitOptions } from './types';
+export declare class AgnosticRuntime {
+    readonly auth: RuntimeAppAuthNamespace;
+    readonly context: RuntimeContextNamespace;
+    readonly data: RuntimeDataNamespace;
+    readonly events: RuntimeEventsNamespace;
+    readonly jobs: RuntimeJobsNamespace;
+    readonly gateway: RuntimeGatewayNamespace;
+    readonly workflows: RuntimeWorkflowsNamespace;
+    readonly workflowRuns: RuntimeWorkflowRunsNamespace;
+    private readonly openapi;
+    private readonly runtimeContext;
+    constructor(config?: AgnosticRuntimeConfig);
+    getRuntimeContext(): ResolvedRuntimeContext;
+}
+export declare class RuntimeAppAuthNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    requireSession(request: RuntimeAppAuthRequestLike | string, options?: RuntimeRequestOptions): Promise<RuntimeAppAuthSession>;
+    getUser(userId: string, options?: RuntimeRequestOptions): Promise<RuntimeAppAuthUserResult>;
+}
+export declare function createAgnosticRuntime(config?: AgnosticRuntimeConfig): AgnosticRuntime;
+export declare class RuntimeContextNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    get(options?: RuntimeRequestOptions): Promise<RuntimeIdentityContext>;
+}
+export declare class RuntimeDataNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    table(tableName: string): RuntimeDataTableClient;
+    view(viewId: string): RuntimeDataViewClient;
+}
+export declare class RuntimeDataTableClient {
+    private readonly tableName;
+    readonly records: RuntimeDataRecordsClient;
+    constructor(openapi: RuntimeOpenApiClient, tableName: string);
+}
+export declare class RuntimeDataRecordsClient {
+    private readonly openapi;
+    private readonly tableName;
+    constructor(openapi: RuntimeOpenApiClient, tableName: string);
+    list(query?: RuntimeListRecordsOptions, options?: RuntimeRequestOptions): Promise<RuntimeRecordsList>;
+    create(input: RuntimeCreateRecordInput | RuntimeRowData, options?: RuntimeRequestOptions): Promise<RuntimeRecordMutation>;
+    update(recordId: string, input: RuntimeUpdateRecordInput | RuntimeRowData, options?: RuntimeRequestOptions): Promise<RuntimeRecordMutation>;
+    delete(recordId: string, options?: RuntimeRequestOptions): Promise<RuntimeRecordMutation>;
+}
+export declare class RuntimeDataViewClient {
+    readonly table: RuntimeDataViewTableClient;
+    constructor(openapi: RuntimeOpenApiClient, viewId: string);
+}
+export declare class RuntimeDataViewTableClient {
+    private readonly openapi;
+    private readonly viewId;
+    constructor(openapi: RuntimeOpenApiClient, viewId: string);
+    window(query?: RuntimeListWindowOptions, options?: RuntimeRequestOptions): Promise<RuntimeTableWindow>;
+}
+export declare class RuntimeEventsNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    publish(eventName: string, payload?: Record<string, unknown>, options?: RuntimeQueueOptions & RuntimeRequestOptions): Promise<RuntimeQueuedMessage>;
+    publishBatch(eventName: string, messages: Array<{
+        payload?: Record<string, unknown>;
+        options?: RuntimeQueueOptions & RuntimeRequestOptions;
+    }>, options?: RuntimeRequestOptions): Promise<RuntimeQueuedMessage[]>;
+}
+export declare class RuntimeJobsNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    enqueue(jobName: string, payload?: Record<string, unknown>, options?: RuntimeQueueOptions & RuntimeRequestOptions): Promise<RuntimeQueuedMessage>;
+}
+export declare class RuntimeGatewayNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    call(routeName: string, payload?: Record<string, unknown>, options?: RuntimeGatewayCallOptions): Promise<RuntimeGatewayCallResult>;
+}
+export declare class RuntimeWorkflowsNamespace {
+    private readonly openapi;
+    private readonly workflowRuns;
+    constructor(openapi: RuntimeOpenApiClient, workflowRuns: RuntimeWorkflowRunsNamespace);
+    start(workflowSlug: string, inputPayload?: Record<string, unknown>, options?: RuntimeRequestOptions): Promise<RuntimeWorkflowRun>;
+    getRun(runId: string, options?: RuntimeRequestOptions): Promise<RuntimeWorkflowRun>;
+}
+export declare class RuntimeWorkflowRunsNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    get(runId: string, options?: RuntimeRequestOptions): Promise<RuntimeWorkflowRun>;
+    wait(runId: string, options?: RuntimeWorkflowWaitOptions): Promise<RuntimeWorkflowRun>;
+    listSteps(runId: string, options?: RuntimeRequestOptions): Promise<RuntimeWorkflowStepRun[]>;
+}