@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/clickup/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { providerFetch, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { providerFetch, ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const clickupApiOrigin = "https://api.clickup.com";
 const clickupApiV2BaseUrl = `${clickupApiOrigin}/api/v2`;
 const clickupApiV3BaseUrl = `${clickupApiOrigin}/api/v3`;
@@ -85,7 +85,7 @@ export const clickupActionHandlers = {
             return asStringId(parsedCandidate.id) === workspaceId;
         });
         if (!workspace) {
-            throw clickupRuntimeError("invalid_input", `unknown clickup workspace: ${workspaceId}`, 400);
+            throw providerInputError(`unknown clickup workspace: ${workspaceId}`);
         }
         return {
             members: readArrayField(workspace, "members"),
@@ -1016,7 +1016,7 @@ async function requestClickupJson(input) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw clickupRuntimeError("provider_error", `ClickUp request failed: ${message}`, 502);
+        throw providerResponseError(`ClickUp request failed: ${message}`);
     }
     const objectPayload = await parseClickupJsonResponse(response, "ClickUp response");
     if (!response.ok) {
@@ -1042,11 +1042,11 @@ async function parseClickupJsonResponse(response, label) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw clickupRuntimeError("provider_error", `${label} parsing failed: ${message}`, 502);
+        throw providerResponseError(`${label} parsing failed: ${message}`);
     }
     const objectPayload = optionalRecord(payload);
     if (!objectPayload) {
-        throw clickupRuntimeError("provider_error", `${label} parsing failed: invalid JSON shape`, 502);
+        throw providerResponseError(`${label} parsing failed: invalid JSON shape`);
     }
     return objectPayload;
 }
@@ -1054,17 +1054,17 @@ function mapClickupError(input) {
     const message = readErrorMessage(input.payload, input.status);
     if (input.status === 401) {
         if (input.mode === "validate") {
-            return clickupRuntimeError("invalid_input", message, 400);
+            return providerInputError(message);
         }
-        return clickupRuntimeError("credential_expired", message, 401);
+        return new ProviderRequestError(401, message);
     }
     if (input.status === 429) {
-        return clickupRuntimeError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (input.status === 400 || (input.status === 404 && input.notFoundAsInvalidInput)) {
-        return clickupRuntimeError("invalid_input", message, 400);
+        return providerInputError(message);
     }
-    return clickupRuntimeError("provider_error", message, 502);
+    return providerResponseError(message);
 }
 function readErrorMessage(payload, status) {
     return (optionalString(payload.err) ??
@@ -1075,7 +1075,7 @@ function readErrorMessage(payload, status) {
 function readObjectField(payload, key) {
     const value = optionalRecord(payload[key]);
     if (!value) {
-        throw clickupRuntimeError("provider_error", `ClickUp response is missing ${key}`, 502);
+        throw providerResponseError(`ClickUp response is missing ${key}`);
     }
     return value;
 }
@@ -1085,7 +1085,7 @@ function readWrappedObject(payload, key) {
 function readArrayField(payload, key) {
     const value = payload[key];
     if (!Array.isArray(value)) {
-        throw clickupRuntimeError("provider_error", `ClickUp response is missing ${key}`, 502);
+        throw providerResponseError(`ClickUp response is missing ${key}`);
     }
     return value;
 }
@@ -1097,7 +1097,7 @@ function normalizeTaskTemplates(templates) {
         const parsed = optionalRecord(template);
         const id = asStringId(parsed?.id);
         if (!parsed || !id) {
-            throw clickupRuntimeError("provider_error", "ClickUp template entry is invalid", 502);
+            throw providerResponseError("ClickUp template entry is invalid");
         }
         return {
             ...parsed,
@@ -1133,7 +1133,7 @@ function readListLikeObject(payload) {
     if (looksLikeList(payload)) {
         return normalizeListLikeObject(payload);
     }
-    throw clickupRuntimeError("provider_error", "ClickUp response is missing list", 502);
+    throw providerResponseError("ClickUp response is missing list");
 }
 function looksLikeList(payload) {
     return asStringId(payload.id) !== undefined && optionalString(payload.name) !== undefined;
@@ -1260,7 +1260,7 @@ function buildListTemplateOptions(value) {
 function buildSetCustomFieldValueBody(input) {
     const value = input.value;
     if (value === undefined) {
-        throw clickupRuntimeError("invalid_input", "value is required", 400);
+        throw providerInputError("value is required");
     }
     return compactObject({
         value,
@@ -1274,7 +1274,7 @@ function buildCreateChecklistBody(input) {
 }
 function buildUpdateChecklistBody(input) {
     if (optionalString(input.name) === undefined && optionalInteger(input.position) === undefined) {
-        throw clickupRuntimeError("invalid_input", "at least one writable field is required", 400);
+        throw providerInputError("at least one writable field is required");
     }
     return compactObject({
         name: optionalString(input.name),
@@ -1292,7 +1292,7 @@ function buildUpdateChecklistItemBody(input) {
         input.assignee === undefined &&
         optionalBoolean(input.resolved) === undefined &&
         input.parent === undefined) {
-        throw clickupRuntimeError("invalid_input", "at least one writable field is required", 400);
+        throw providerInputError("at least one writable field is required");
     }
     return compactObject({
         name: optionalString(input.name),
@@ -1322,7 +1322,7 @@ async function resolveClickupAttachmentSource(input, fetcher) {
     const contentBase64 = optionalString(input.contentBase64);
     const providedSources = [url, contentText, contentBase64].filter((value) => value !== undefined).length;
     if (providedSources !== 1) {
-        throw clickupRuntimeError("invalid_input", "exactly one attachment source field is required", 400);
+        throw providerInputError("exactly one attachment source field is required");
     }
     if (url) {
         const response = await fetchPublicAttachmentUrl(fetcher, url);
@@ -1340,7 +1340,7 @@ async function resolveClickupAttachmentSource(input, fetcher) {
         };
     }
     if (contentBase64 === undefined) {
-        throw clickupRuntimeError("invalid_input", "attachment source is required", 400);
+        throw providerInputError("attachment source is required");
     }
     return {
         bytes: decodeBase64AttachmentContent(contentBase64),
@@ -1354,7 +1354,7 @@ async function fetchPublicAttachmentUrl(fetcher, url) {
     const timeoutPromise = new Promise((_, reject) => {
         timeoutHandle = setTimeout(() => {
             controller.abort();
-            reject(clickupRuntimeError("provider_error", "attachment source download timed out", 504));
+            reject(new ProviderRequestError(504, "attachment source download timed out"));
         }, attachmentDownloadTimeoutMs);
     });
     try {
@@ -1382,13 +1382,13 @@ async function fetchPublicAttachmentUrl(fetcher, url) {
             currentUrl = assertPublicClickupAttachmentUrl(new URL(location, currentUrl).toString());
         }
         if (!response) {
-            throw clickupRuntimeError("provider_error", "attachment source download failed", 502);
+            throw providerResponseError("attachment source download failed");
         }
         if ([301, 302, 303, 307, 308].includes(response.status)) {
-            throw clickupRuntimeError("provider_error", "attachment source redirected too many times", 502);
+            throw providerResponseError("attachment source redirected too many times");
         }
         if (!response.ok) {
-            throw clickupRuntimeError("provider_error", `failed to fetch attachment source: ${response.status}`, response.status);
+            throw new ProviderRequestError(response.status, `failed to fetch attachment source: ${response.status}`);
         }
         return {
             bytes: await Promise.race([readAttachmentResponseBytes(response), timeoutPromise]),
@@ -1403,14 +1403,14 @@ function assertPublicClickupAttachmentUrl(value) {
     return assertPublicHttpUrl(value, {
         fieldName: "url",
         createError(message) {
-            return clickupRuntimeError("invalid_input", message, 400);
+            return providerInputError(message);
         },
     });
 }
 async function readAttachmentResponseBytes(response) {
     const contentLength = parseContentLength(response.headers.get("content-length"));
     if (contentLength != null && contentLength > maxAttachmentBytes) {
-        throw clickupRuntimeError("invalid_input", `attachment source exceeds ${maxAttachmentBytes} bytes`, 400);
+        throw providerInputError(`attachment source exceeds ${maxAttachmentBytes} bytes`);
     }
     const body = response.body;
     if (body == null) {
@@ -1428,7 +1428,7 @@ async function readAttachmentResponseBytes(response) {
             total += value.byteLength;
             if (total > maxAttachmentBytes) {
                 await reader.cancel();
-                throw clickupRuntimeError("invalid_input", `attachment source exceeds ${maxAttachmentBytes} bytes`, 400);
+                throw providerInputError(`attachment source exceeds ${maxAttachmentBytes} bytes`);
             }
             chunks.push(value);
         }
@@ -1451,11 +1451,11 @@ function parseContentLength(value) {
 function decodeBase64AttachmentContent(contentBase64) {
     const normalizedContent = contentBase64.trim();
     if (normalizedContent !== "" && normalizedContent.length % 4 !== 0) {
-        throw clickupRuntimeError("invalid_input", "contentBase64 must be valid base64", 400);
+        throw providerInputError("contentBase64 must be valid base64");
     }
     const bytes = Buffer.from(normalizedContent, "base64");
     if (bytes.toString("base64") !== normalizedContent) {
-        throw clickupRuntimeError("invalid_input", "contentBase64 must be valid base64", 400);
+        throw providerInputError("contentBase64 must be valid base64");
     }
     return Uint8Array.from(bytes);
 }
@@ -1512,7 +1512,7 @@ function buildTaskCommentsQuery(input) {
     const hasStart = optionalInteger(input.start) !== undefined;
     const hasStartId = optionalString(input.startId) !== undefined;
     if (hasStart !== hasStartId) {
-        throw clickupRuntimeError("invalid_input", "start and startId must be provided together", 400);
+        throw providerInputError("start and startId must be provided together");
     }
     return compactQuery({
         start: optionalInteger(input.start),
@@ -1522,21 +1522,21 @@ function buildTaskCommentsQuery(input) {
 function requireProviderString(value, key) {
     const parsed = optionalString(value);
     if (!parsed) {
-        throw clickupRuntimeError("provider_error", `ClickUp response is missing ${key}`, 502);
+        throw providerResponseError(`ClickUp response is missing ${key}`);
     }
     return parsed;
 }
 function requireProviderBoolean(value, key) {
     const parsed = optionalBoolean(value);
     if (parsed === undefined) {
-        throw clickupRuntimeError("provider_error", `ClickUp response is missing ${key}`, 502);
+        throw providerResponseError(`ClickUp response is missing ${key}`);
     }
     return parsed;
 }
 function requireProviderObject(value, key) {
     const parsed = optionalRecord(value);
     if (!parsed) {
-        throw clickupRuntimeError("provider_error", `ClickUp response is missing ${key}`, 502);
+        throw providerResponseError(`ClickUp response is missing ${key}`);
     }
     return parsed;
 }
@@ -1615,7 +1615,7 @@ function buildUpdateTaskBody(input) {
         assigneeUpdates !== undefined ||
         customItemId !== undefined;
     if (!hasWritableField) {
-        throw clickupRuntimeError("invalid_input", "at least one writable field is required", 400);
+        throw providerInputError("at least one writable field is required");
     }
     return compactObject({
         name: optionalString(input.name),
@@ -1649,14 +1649,14 @@ function buildAssigneeUpdates(input) {
 function requireString(value, fieldName) {
     const parsed = optionalString(value);
     if (!parsed) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} is required`, 400);
+        throw providerInputError(`${fieldName} is required`);
     }
     return parsed;
 }
 function requireIdString(value, fieldName) {
     const parsed = asStringId(value);
     if (!parsed) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} is required`, 400);
+        throw providerInputError(`${fieldName} is required`);
     }
     return parsed;
 }
@@ -1665,7 +1665,7 @@ function normalizeStringArray(value, fieldName) {
         return undefined;
     }
     if (!Array.isArray(value)) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be an array`, 400);
+        throw providerInputError(`${fieldName} must be an array`);
     }
     return value.map((item) => requireString(item, fieldName));
 }
@@ -1674,12 +1674,12 @@ function normalizeIntegerArray(value, fieldName) {
         return undefined;
     }
     if (!Array.isArray(value)) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be an array`, 400);
+        throw providerInputError(`${fieldName} must be an array`);
     }
     return value.map((item) => {
         const parsed = optionalInteger(item);
         if (parsed === undefined) {
-            throw clickupRuntimeError("invalid_input", `${fieldName} must contain integers`, 400);
+            throw providerInputError(`${fieldName} must contain integers`);
         }
         return parsed;
     });
@@ -1693,7 +1693,7 @@ function normalizeIntegerOrNone(value, fieldName) {
     }
     const parsed = optionalInteger(value);
     if (parsed === undefined) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be an integer or "none"`, 400);
+        throw providerInputError(`${fieldName} must be an integer or "none"`);
     }
     return parsed;
 }
@@ -1703,7 +1703,7 @@ function normalizeNullableInteger(value, fieldName) {
     }
     const parsed = optionalInteger(value);
     if (parsed === undefined) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be an integer or null`, 400);
+        throw providerInputError(`${fieldName} must be an integer or null`);
     }
     return parsed;
 }
@@ -1716,7 +1716,7 @@ function normalizeStringOrInteger(value, fieldName) {
     }
     const parsed = optionalInteger(value);
     if (parsed === undefined) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be a string or integer`, 400);
+        throw providerInputError(`${fieldName} must be a string or integer`);
     }
     return parsed;
 }
@@ -1729,7 +1729,7 @@ function normalizeStringIntegerOrNull(value, fieldName) {
     }
     const parsed = optionalInteger(value);
     if (parsed === undefined) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be a string, integer, or null`, 400);
+        throw providerInputError(`${fieldName} must be a string, integer, or null`);
     }
     return parsed;
 }
@@ -1738,7 +1738,7 @@ function normalizeNullableString(value, fieldName) {
         return value;
     }
     if (typeof value !== "string") {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be a string or null`, 400);
+        throw providerInputError(`${fieldName} must be a string or null`);
     }
     return value;
 }
@@ -1747,7 +1747,7 @@ function resolveDependencyTarget(input) {
     const dependencyOfTaskId = optionalString(input.dependencyOfTaskId);
     const provided = Number(Boolean(dependsOnTaskId)) + Number(Boolean(dependencyOfTaskId));
     if (provided !== 1) {
-        throw clickupRuntimeError("invalid_input", "exactly one dependency target field is required", 400);
+        throw providerInputError("exactly one dependency target field is required");
     }
     return compactObject({
         depends_on: dependsOnTaskId,
@@ -1759,12 +1759,12 @@ function normalizeMoveTaskStatusMappings(value) {
         return undefined;
     }
     if (!Array.isArray(value)) {
-        throw clickupRuntimeError("invalid_input", "statusMappings must be an array", 400);
+        throw providerInputError("statusMappings must be an array");
     }
     return value.map((entry) => {
         const parsedEntry = optionalRecord(entry);
         if (!parsedEntry) {
-            throw clickupRuntimeError("invalid_input", "statusMappings must contain objects", 400);
+            throw providerInputError("statusMappings must contain objects");
         }
         return compactObject({
             source_status: requireString(parsedEntry.sourceStatus, "statusMappings.sourceStatus"),
@@ -1778,7 +1778,7 @@ function normalizeOptionalObject(value, fieldName) {
     }
     const parsed = optionalRecord(value);
     if (!parsed) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be an object`, 400);
+        throw providerInputError(`${fieldName} must be an object`);
     }
     return parsed;
 }
@@ -1787,12 +1787,12 @@ function normalizeRecordArray(value, fieldName) {
         return undefined;
     }
     if (!Array.isArray(value)) {
-        throw clickupRuntimeError("invalid_input", `${fieldName} must be an array`, 400);
+        throw providerInputError(`${fieldName} must be an array`);
     }
     return value.map((item) => {
         const parsed = optionalRecord(item);
         if (!parsed) {
-            throw clickupRuntimeError("invalid_input", `${fieldName} must contain objects`, 400);
+            throw providerInputError(`${fieldName} must contain objects`);
         }
         return parsed;
     });
@@ -1809,6 +1809,3 @@ function asStringId(value) {
 function compactQuery(value) {
     return Object.fromEntries(Object.entries(value).filter(([, child]) => child !== undefined));
 }
-function clickupRuntimeError(_code, message, status = 500) {
-    return new ProviderRequestError(status, message);
-}

package/src/providers/cnb/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const cnbActions: ActionDefinition[];