@tapi-dev/sdk 0.1.34 → 0.1.38

package/dist/client.d.ts

@@ -1,7 +1,8 @@
 import type { TapiClientOptions } from "./types.js";
 export declare class HttpClient {
     private readonly baseUrl;
-    private readonly apiKey;
+    private readonly authToken;
+    private readonly tappId;
     private readonly projectId?;
     private readonly fetchImpl;
     constructor(options: TapiClientOptions);

package/dist/client.js

@@ -1,12 +1,28 @@
 import { TapiError } from "./errors.js";
 export class HttpClient {
     baseUrl;
-    apiKey;
+    authToken;
+    tappId;
     projectId;
     fetchImpl;
     constructor(options) {
         this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-        this.apiKey = options.apiKey;
+        this.authToken = options.authToken.trim();
+        if (!this.authToken) {
+            throw new TapiError("authToken is required", {
+                status: 0,
+                code: "invalid_client_config",
+                details: { field: "authToken" },
+            });
+        }
+        this.tappId = options.tappId.trim();
+        if (!this.tappId) {
+            throw new TapiError("tappId is required", {
+                status: 0,
+                code: "invalid_client_config",
+                details: { field: "tappId" },
+            });
+        }
         this.projectId = options.projectId;
         this.fetchImpl = options.fetch ?? fetch;
     }
@@ -26,8 +42,9 @@ export class HttpClient {
         const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
             method,
             headers: {
-                Authorization: `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.authToken}`,
                 "Content-Type": "application/json",
+                "X-Tapi-Tapp": this.tappId,
                 ...(this.projectId ? { "X-Tapi-Project": this.projectId } : {}),
             },
             body: body === undefined ? undefined : JSON.stringify(body),

package/dist/cloud-runs.js

@@ -1,10 +1,11 @@
+import { normalizeCloudBatchRun } from "./service-contract.js";
 export class CloudRunsResource {
     http;
     constructor(http) {
         this.http = http;
     }
-    get(runId) {
-        return this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}`);
+    async get(runId) {
+        return normalizeCloudBatchRun(await this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}`));
     }
     events(runId) {
         return this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/events`);
@@ -12,8 +13,8 @@ export class CloudRunsResource {
     results(runId) {
         return this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/results`);
     }
-    cancel(runId) {
-        return this.http.post(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/cancel`);
+    async cancel(runId) {
+        return normalizeCloudBatchRun(await this.http.post(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/cancel`));
     }
     balance(user) {
         return this.http.get(`/api/sdk/v1/billing/cloud/balance${cloudUserQuery(user)}`);

package/dist/runs.js

@@ -1,16 +1,17 @@
+import { normalizeTapiRun } from "./service-contract.js";
 export class RunsResource {
     http;
     constructor(http) {
         this.http = http;
     }
-    get(runId) {
-        return this.http.get(`/api/sdk/v1/runs/${encodeURIComponent(runId)}`);
+    async get(runId) {
+        return normalizeTapiRun(await this.http.get(`/api/sdk/v1/runs/${encodeURIComponent(runId)}`));
     }
-    cancel(runId) {
-        return this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/cancel`);
+    async cancel(runId) {
+        return normalizeTapiRun(await this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/cancel`));
     }
-    provideInput(runId, inputKey, value) {
-        return this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/inputs/${encodeURIComponent(inputKey)}`, { value });
+    async provideInput(runId, inputKey, value) {
+        return normalizeTapiRun(await this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/inputs/${encodeURIComponent(inputKey)}`, { value }));
     }
     async wait(runId, options = {}) {
         const intervalMs = options.intervalMs ?? 1000;

package/dist/service-contract.d.ts

@@ -0,0 +1,6 @@
+import type { CloudBatchRun, SdkCatalog, ServiceOperation, TapiDevSessionsList, TapiRun } from "./types.js";
+export declare function normalizeSdkCatalog(payload: unknown): SdkCatalog;
+export declare function normalizeServiceOperation(payload: unknown): ServiceOperation;
+export declare function normalizeTapiRun(payload: unknown): TapiRun;
+export declare function normalizeCloudBatchRun(payload: unknown): CloudBatchRun;
+export declare function normalizeDevSessions(payload: TapiDevSessionsList): TapiDevSessionsList;

package/dist/service-contract.js

@@ -0,0 +1,84 @@
+const RETIRED_SERVICE_NAME_FIELD = "api" + "Name";
+const RETIRED_SERVICE_KEY_FIELD = "request" + "Key";
+const RETIRED_CATALOG_FIELD = "ap" + "is";
+export function normalizeSdkCatalog(payload) {
+    const record = isRecord(payload) ? payload : {};
+    rejectRetiredCatalogShape(record);
+    const currentServices = Array.isArray(record.services) ? record.services : [];
+    return {
+        services: currentServices.map(normalizeCatalogService),
+    };
+}
+export function normalizeServiceOperation(payload) {
+    return normalizeServiceIdentity(payload);
+}
+export function normalizeTapiRun(payload) {
+    return normalizeServiceIdentity(payload);
+}
+export function normalizeCloudBatchRun(payload) {
+    return normalizeServiceIdentity(payload);
+}
+export function normalizeDevSessions(payload) {
+    return {
+        ...payload,
+        groups: (payload.groups || []).map((group) => ({
+            ...group,
+            sessions: (group.sessions || []).map((session) => normalizeServiceIdentity(session)),
+        })),
+    };
+}
+function normalizeCatalogService(payload) {
+    const record = normalizeServiceIdentity(payload, { requireIdentity: false });
+    const serviceName = stringField(record.serviceName).trim();
+    if (!serviceName) {
+        throw new Error("SDK service catalog responses must use serviceName.");
+    }
+    record.serviceName = serviceName;
+    if (Array.isArray(record.requests)) {
+        record.requests = record.requests.map(normalizeCatalogRequest);
+    }
+    return record;
+}
+function normalizeCatalogRequest(payload) {
+    return normalizeServiceIdentity(payload);
+}
+function normalizeServiceIdentity(payload, options = {}) {
+    const record = isRecord(payload) ? { ...payload } : {};
+    rejectRetiredServiceIdentity(record);
+    const serviceName = stringField(record.serviceName).trim();
+    const serviceKey = stringField(record.serviceKey).trim();
+    if (serviceName) {
+        record.serviceName = serviceName;
+    }
+    if (serviceKey) {
+        record.serviceKey = serviceKey;
+    }
+    if (options.requireIdentity !== false) {
+        requireServiceIdentity(serviceName, serviceKey);
+    }
+    if (!stringField(record.serviceRun) && serviceName && serviceKey) {
+        record.serviceRun = `${serviceName}.${serviceKey}`;
+    }
+    return record;
+}
+function rejectRetiredServiceIdentity(record) {
+    if (RETIRED_SERVICE_NAME_FIELD in record || RETIRED_SERVICE_KEY_FIELD in record) {
+        throw new Error("SDK service responses must use serviceName/serviceKey fields.");
+    }
+}
+function rejectRetiredCatalogShape(record) {
+    if (RETIRED_CATALOG_FIELD in record) {
+        throw new Error("SDK service catalog responses must use services.");
+    }
+}
+function requireServiceIdentity(serviceName, serviceKey) {
+    if (!serviceName || !serviceKey) {
+        throw new Error("SDK service responses must use serviceName/serviceKey fields.");
+    }
+}
+function stringField(value) {
+    return typeof value === "string" ? value : "";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/services.d.ts

@@ -4,14 +4,15 @@ import type { TapiClientOptions } from "./types.js";
 export declare class ServicesResource {
     private readonly http;
     private readonly dev;
+    private readonly tappId;
     constructor(http: HttpClient, options: TapiClientOptions);
-    run(serviceRequest: string, request?: ServiceRunRequest): Promise<TapiRun>;
-    quoteCloud(serviceRequest: string, request?: ServiceCloudQuoteRequest): Promise<CloudRunQuote>;
-    runCloud(serviceRequest: string, request?: ServiceRunRequest & {
+    run(serviceRun: string, request: ServiceRunRequest): Promise<TapiRun>;
+    quoteCloud(serviceRun: string, request?: ServiceCloudQuoteRequest): Promise<CloudRunQuote>;
+    runCloud(serviceRun: string, request: ServiceRunRequest & {
         cloud?: ServiceCloudBatchRequest["cloud"];
         user?: ServiceCloudBatchRequest["user"];
         payment?: ServiceCloudBatchRequest["payment"];
     }): Promise<CloudBatchRun>;
-    runCloudBatch(serviceRequest: string, request: ServiceCloudBatchRequest): Promise<CloudBatchRun>;
-    describe(serviceRequest: string): Promise<ServiceOperation>;
+    runCloudBatch(serviceRun: string, request: ServiceCloudBatchRequest): Promise<CloudBatchRun>;
+    describe(serviceRun: string): Promise<ServiceOperation>;
 }

package/dist/services.js

@@ -1,44 +1,97 @@
 import { TapiError } from "./errors.js";
 import { attachLateInputs, serializeInputs } from "./late-input.js";
+import { normalizeCloudBatchRun, normalizeServiceOperation, normalizeTapiRun, } from "./service-contract.js";
+const RETIRED_RUN_BODY_SERVICE_MAP_FIELDS = [
+    "sitemap" + "Id",
+    "sitemap_id",
+    "serviceMapId",
+    "service_map_id",
+];
+const RUNTIME_OWNER_ALIAS_FIELDS = ["runtimeOwner", "runtime_owner"];
+const RUNTIME_SERVICE_MAP_SELECTOR_FIELDS = [
+    "sitemap" + "Id",
+    "sitemap_id",
+    "serviceMapId",
+    "service_map_id",
+];
+const RUN_BODY_SERVICE_IDENTITY_FIELDS = [
+    "serviceName",
+    "serviceKey",
+    "serviceRun",
+    "service_name",
+    "service_key",
+    "service_run",
+];
+const SERVICE_RUN_RUNTIME_OWNER = "service_run";
 export class ServicesResource {
     http;
     dev;
+    tappId;
     constructor(http, options) {
         this.http = http;
         this.dev = options.dev === true;
+        this.tappId = options.tappId.trim();
+        if (!this.tappId) {
+            throw new TapiError("tappId is required", {
+                status: 0,
+                code: "invalid_client_config",
+                details: { field: "tappId" },
+            });
+        }
     }
-    async run(serviceRequest, request = {}) {
-        const { serviceName, requestKey } = splitServiceRequest(serviceRequest);
+    async run(serviceRun, request) {
+        const { serviceName, serviceKey } = splitServiceRun(serviceRun);
+        rejectRetiredRunBodySelectors(request);
         const { bodyInputs, lateInputs } = serializeInputs(request.inputs);
+        const runtime = normalizeServiceRunRuntime(request.runtime);
+        const tappId = normalizePathSegment(this.tappId, "tappId");
+        const queueId = normalizePathSegment(request.queueId, "queueId");
+        const { queueId: _queueId, ...requestBody } = request;
         const body = {
-            ...request,
+            ...requestBody,
             ...(bodyInputs === undefined ? {} : { inputs: bodyInputs }),
+            ...(runtime === undefined ? {} : { runtime }),
             ...(this.dev ? { dev: true } : {}),
         };
-        const run = await this.http.post(`/api/sdk/v1/services/${encodeURIComponent(serviceName)}/requests/${encodeURIComponent(requestKey)}/runs`, body);
+        const run = normalizeTapiRun(await this.http.post(`/api/sdk/v1/tapps/${encodeURIComponent(tappId)}/queues/${encodeURIComponent(queueId)}/services/${encodeURIComponent(`${serviceName}.${serviceKey}`)}/runs`, body));
         if (run.id && lateInputs.length > 0) {
             attachLateInputs(lateInputs, run.id, (runId, inputKey, value) => this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/inputs/${encodeURIComponent(inputKey)}`, { value }));
         }
         return run;
     }
-    quoteCloud(serviceRequest, request = {}) {
-        const { serviceName, requestKey } = splitServiceRequest(serviceRequest);
-        return this.http.post(`/api/sdk/v1/services/${encodeURIComponent(serviceName)}/requests/${encodeURIComponent(requestKey)}/cloud/quote`, request);
+    quoteCloud(serviceRun, request = {}) {
+        const { serviceName, serviceKey } = splitServiceRun(serviceRun);
+        rejectRetiredRunBodySelectors(request);
+        const runtime = normalizeServiceRunRuntime(request.runtime);
+        const body = {
+            ...request,
+            ...(runtime === undefined ? {} : { runtime }),
+        };
+        return this.http.post(`/api/sdk/v1/services/${encodeURIComponent(serviceName)}/service-keys/${encodeURIComponent(serviceKey)}/cloud/quote`, body);
     }
-    runCloud(serviceRequest, request = {}) {
-        return this.runCloudBatch(serviceRequest, {
+    runCloud(serviceRun, request) {
+        rejectRetiredRunBodySelectors(request);
+        return this.runCloudBatch(serviceRun, {
             inputs: [request.inputs ?? {}],
+            queueId: request.queueId,
             cloud: request.cloud,
             user: request.user,
+            runtime: request.runtime,
             payment: request.payment,
             site: typeof request.site === "string" ? request.site : undefined,
             idempotencyKey: request.idempotencyKey,
         });
     }
-    async runCloudBatch(serviceRequest, request) {
-        const { serviceName, requestKey } = splitServiceRequest(serviceRequest);
+    async runCloudBatch(serviceRun, request) {
+        const { serviceName, serviceKey } = splitServiceRun(serviceRun);
+        rejectRetiredRunBodySelectors(request);
+        const runtime = normalizeServiceRunRuntime(request.runtime);
+        const body = {
+            ...request,
+            ...(runtime === undefined ? {} : { runtime }),
+        };
         try {
-            return await this.http.post(`/api/sdk/v1/services/${encodeURIComponent(serviceName)}/requests/${encodeURIComponent(requestKey)}/cloud/batch`, request);
+            return normalizeCloudBatchRun(await this.http.post(`/api/sdk/v1/services/${encodeURIComponent(serviceName)}/service-keys/${encodeURIComponent(serviceKey)}/cloud/batch`, body));
         }
         catch (error) {
             if (error instanceof TapiError && error.status === 402 && isRecord(error.details)) {
@@ -47,26 +100,72 @@ export class ServicesResource {
             throw error;
         }
     }
-    describe(serviceRequest) {
-        const { serviceName, requestKey } = splitServiceRequest(serviceRequest);
-        return this.http.get(`/api/sdk/v1/services/${encodeURIComponent(serviceName)}/requests/${encodeURIComponent(requestKey)}`);
+    async describe(serviceRun) {
+        const { serviceName, serviceKey } = splitServiceRun(serviceRun);
+        const tappId = normalizePathSegment(this.tappId, "tappId");
+        return normalizeServiceOperation(await this.http.get(`/api/sdk/v1/tapps/${encodeURIComponent(tappId)}/services/${encodeURIComponent(`${serviceName}.${serviceKey}`)}`));
+    }
+}
+function rejectRetiredRunBodySelectors(request) {
+    const raw = isRecord(request) ? request : {};
+    for (const field of RETIRED_RUN_BODY_SERVICE_MAP_FIELDS) {
+        if (field in raw) {
+            throw new Error("service runs are addressed by serviceRun; body ServiceMap selectors are not accepted.");
+        }
+    }
+    for (const field of RUN_BODY_SERVICE_IDENTITY_FIELDS) {
+        if (field in raw) {
+            throw new Error("service runs are addressed by serviceRun; body service identity fields are not accepted.");
+        }
+    }
+}
+function normalizeServiceRunRuntime(runtime) {
+    if (!isRecord(runtime)) {
+        return undefined;
+    }
+    for (const field of RUNTIME_OWNER_ALIAS_FIELDS) {
+        if (field in runtime) {
+            throw new Error(`unsupported service run runtime field: ${field}`);
+        }
+    }
+    for (const field of RUNTIME_SERVICE_MAP_SELECTOR_FIELDS) {
+        if (field in runtime) {
+            throw new Error(`unsupported service run runtime field: ${field}`);
+        }
     }
+    const normalized = { ...runtime };
+    const owner = String(normalized.owner ?? "").trim().toLowerCase();
+    if (owner && owner !== SERVICE_RUN_RUNTIME_OWNER) {
+        throw new Error("service-run runtime owner must be service_run.");
+    }
+    normalized.owner = SERVICE_RUN_RUNTIME_OWNER;
+    return normalized;
 }
-function splitServiceRequest(value) {
+function splitServiceRun(value) {
     const text = value.trim();
     const index = text.lastIndexOf(".");
     if (index <= 0 || index === text.length - 1) {
-        throw new Error("service request must be formatted as '<serviceName>.<requestKey>'");
+        throw new Error("serviceRun must be formatted as '<serviceName>.<serviceKey>'");
     }
     return {
         serviceName: text.slice(0, index),
-        requestKey: text.slice(index + 1),
+        serviceKey: text.slice(index + 1),
     };
 }
+function normalizePathSegment(value, label) {
+    const text = typeof value === "string" ? value.trim() : "";
+    if (!text) {
+        throw new Error(`${label} is required.`);
+    }
+    if (text.includes("/") || text.includes("\\") || text.includes("..")) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return text;
+}
 function cloudPaymentRequiredRun(detail) {
     const run = isRecord(detail.run) ? detail.run : {};
     const quote = isRecord(detail.quote) ? detail.quote : undefined;
-    return {
+    return normalizeCloudBatchRun({
         ...run,
         id: typeof run.id === "string" ? run.id : "",
         status: "payment_required",
@@ -79,7 +178,7 @@ function cloudPaymentRequiredRun(detail) {
         paymentProviderEnabled: typeof detail.paymentProviderEnabled === "boolean" ? detail.paymentProviderEnabled : undefined,
         availableBalanceCents: typeof detail.availableBalanceCents === "number" ? detail.availableBalanceCents : undefined,
         requiredBalanceCents: typeof detail.requiredBalanceCents === "number" ? detail.requiredBalanceCents : undefined,
-    };
+    });
 }
 function cloudRunUser(value) {
     if (!isRecord(value) || typeof value.externalUserId !== "string") {

package/dist/sessions.js

@@ -1,14 +1,15 @@
+import { normalizeDevSessions } from "./service-contract.js";
 export class SessionsResource {
     http;
     constructor(http) {
         this.http = http;
     }
-    list(options = {}) {
+    async list(options = {}) {
         const params = new URLSearchParams();
         if (options.site) {
             params.set("site", options.site);
         }
         const query = params.toString();
-        return this.http.get(`/api/sdk/v1/dev/sessions${query ? `?${query}` : ""}`);
+        return normalizeDevSessions(await this.http.get(`/api/sdk/v1/dev/sessions${query ? `?${query}` : ""}`));
     }
 }

package/dist/triggers.d.ts

@@ -1,17 +1,17 @@
 import type { HttpClient } from "./client.js";
-import type { WebsiteApiTrigger, WebsiteApiTriggerCreateRequest, WebsiteApiTriggerList, WebsiteApiTriggerRunResult, WebsiteApiTriggerUpdateRequest } from "./types.js";
+import type { ServiceTrigger, ServiceTriggerCreateRequest, ServiceTriggerList, ServiceTriggerRunResult, ServiceTriggerUpdateRequest } from "./types.js";
 export declare class TriggersResource {
     private readonly http;
     constructor(http: HttpClient);
-    list(): Promise<WebsiteApiTriggerList>;
-    create(request: WebsiteApiTriggerCreateRequest): Promise<WebsiteApiTrigger>;
-    get(triggerId: string): Promise<WebsiteApiTrigger>;
-    update(triggerId: string, request: WebsiteApiTriggerUpdateRequest): Promise<WebsiteApiTrigger>;
-    enable(triggerId: string): Promise<WebsiteApiTrigger>;
-    disable(triggerId: string): Promise<WebsiteApiTrigger>;
+    list(): Promise<ServiceTriggerList>;
+    create(request: ServiceTriggerCreateRequest): Promise<ServiceTrigger>;
+    get(triggerId: string): Promise<ServiceTrigger>;
+    update(triggerId: string, request: ServiceTriggerUpdateRequest): Promise<ServiceTrigger>;
+    enable(triggerId: string): Promise<ServiceTrigger>;
+    disable(triggerId: string): Promise<ServiceTrigger>;
     delete(triggerId: string): Promise<{
         deleted: boolean;
         id: string;
     }>;
-    fire(triggerId: string): Promise<WebsiteApiTriggerRunResult>;
+    fire(triggerId: string): Promise<ServiceTriggerRunResult>;
 }

package/dist/triggers.js

@@ -1,3 +1,18 @@
+const RETIRED_TRIGGER_TARGET_FIELD = "api" + "Request";
+const RETIRED_TRIGGER_BODY_SERVICE_MAP_FIELDS = [
+    "sitemap" + "Id",
+    "sitemap_id",
+    "serviceMapId",
+    "service_map_id",
+];
+const RUNTIME_OWNER_ALIAS_FIELDS = ["runtimeOwner", "runtime_owner"];
+const RUNTIME_SERVICE_MAP_SELECTOR_FIELDS = [
+    "sitemap" + "Id",
+    "sitemap_id",
+    "serviceMapId",
+    "service_map_id",
+];
+const SERVICE_RUN_RUNTIME_OWNER = "service_run";
 export class TriggersResource {
     http;
     constructor(http) {
@@ -29,13 +44,47 @@ export class TriggersResource {
     }
 }
 function toServiceTriggerWireRequest(request) {
-    const apiRequest = request.serviceRun ?? request.service ?? request.apiRequest;
-    if (!apiRequest) {
+    const raw = request;
+    if (RETIRED_TRIGGER_TARGET_FIELD in raw) {
+        throw new Error("service trigger uses serviceRun; retired trigger target fields are not accepted.");
+    }
+    for (const field of RETIRED_TRIGGER_BODY_SERVICE_MAP_FIELDS) {
+        if (field in raw) {
+            throw new Error("service triggers are addressed by serviceRun; body ServiceMap selectors are not accepted.");
+        }
+    }
+    if (typeof request.serviceRun !== "string" || !request.serviceRun.trim()) {
         throw new Error("service trigger requires serviceRun.");
     }
-    const { serviceRun, service, ...wireRequest } = request;
+    const runtime = normalizeServiceTriggerRuntime(request.runtime);
     return {
-        ...wireRequest,
-        apiRequest,
+        ...request,
+        serviceRun: request.serviceRun.trim(),
+        ...(runtime === undefined ? {} : { runtime }),
     };
 }
+function normalizeServiceTriggerRuntime(runtime) {
+    if (!isRecord(runtime)) {
+        return undefined;
+    }
+    for (const field of RUNTIME_OWNER_ALIAS_FIELDS) {
+        if (field in runtime) {
+            throw new Error(`unsupported service trigger runtime field: ${field}`);
+        }
+    }
+    for (const field of RUNTIME_SERVICE_MAP_SELECTOR_FIELDS) {
+        if (field in runtime) {
+            throw new Error(`unsupported service trigger runtime field: ${field}`);
+        }
+    }
+    const normalized = { ...runtime };
+    const owner = String(normalized.owner ?? "").trim().toLowerCase();
+    if (owner && owner !== SERVICE_RUN_RUNTIME_OWNER) {
+        throw new Error("service trigger runtime owner must be service_run.");
+    }
+    normalized.owner = SERVICE_RUN_RUNTIME_OWNER;
+    return normalized;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}