@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/sansan/organization.d.ts

@@ -0,0 +1,2 @@
+import type { SansanActionHandler } from "./request.ts";
+export declare const sansanOrganizationHandlers: Record<string, SansanActionHandler>;

package/src/providers/sansan/organization.js

@@ -0,0 +1,88 @@
+import { optionalNumber, optionalString } from "../../core/cast.js";
+import { providerResponseError, requiredResponseRecord } from "../provider-runtime.js";
+import { downloadSansanSource, encodeSansanMultipart, requireSansanTransit, uploadSansanDownload } from "./files.js";
+import { sansanDepartmentColumns, sansanUserColumns } from "./organization-columns.js";
+import { requestSansan, requestSansanJson, sansanPathId } from "./request.js";
+export const sansanOrganizationHandlers = {
+    async export_organization_users(input, context) {
+        return exportOrganization("users", input, context);
+    },
+    async export_organization_departments(input, context) {
+        return exportOrganization("departments", input, context);
+    },
+    async check_organization_import(input, context) {
+        const multipart = await buildOrganizationMultipart(input, context);
+        return requestSansan("/organization/check", { method: "POST", query: { delimiter: input.delimiter }, ...multipart }, context, async (response) => {
+            const csv = await response.text();
+            if (!csv.trim())
+                return { valid: true, report: null };
+            requireSansanTransit(context);
+            const report = await uploadSansanDownload(new Response(csv, { headers: { "content-type": "text/csv" } }), "sansan-import-validation.csv", "text/csv", context);
+            return { valid: false, report };
+        });
+    },
+    async submit_organization_import(input, context) {
+        const multipart = await buildOrganizationMultipart(input, context);
+        const result = await requestSansanJson("/organization/jobs", { method: "POST", query: { delimiter: input.delimiter }, ...multipart }, context);
+        if (!optionalString(result.importId))
+            throw providerResponseError("Sansan import response is missing importId");
+        return result;
+    },
+    async get_organization_import_status(input, context) {
+        return getImportStatus(input, context);
+    },
+    async get_organization_import_result(input, context) {
+        const result = await getImportStatus(input, context);
+        let report = null;
+        if (result.status === "completed" || result.status === "failed") {
+            requireSansanTransit(context);
+            const id = sansanPathId(input.importId, "importId");
+            report = await requestSansan(`/organization/jobs/${id}/result`, {}, context, (response) => uploadSansanDownload(response, "sansan-import-result.csv", "text/csv", context));
+        }
+        return { ...result, importId: input.importId, report };
+    },
+};
+async function exportOrganization(resource, input, context) {
+    requireSansanTransit(context);
+    return requestSansan(`/organization/${resource}`, { query: { delimiter: input.delimiter } }, context, (response) => uploadSansanDownload(response, `sansan-${resource}.csv`, "text/csv", context));
+}
+async function getImportStatus(input, context) {
+    const id = sansanPathId(input.importId, "importId");
+    const result = await requestSansanJson(`/organization/jobs/${id}`, {}, context);
+    const code = optionalNumber(result.importStatus);
+    const states = { 0: "queued", 1: "running", 2: "completed", 9: "failed" };
+    const status = code === undefined ? undefined : states[code];
+    if (!status)
+        throw providerResponseError("Sansan returned an unknown importStatus");
+    return { ...result, importStatus: code, status };
+}
+async function buildOrganizationMultipart(input, context) {
+    const form = new FormData();
+    const separators = { comma: ",", semicolon: ";", tab: "\t", space: " " };
+    const separator = separators[optionalString(input.delimiter) ?? "comma"];
+    for (const [field, part, columns] of [
+        ["users", "user", sansanUserColumns],
+        ["departments", "department", sansanDepartmentColumns],
+    ]) {
+        const urlField = `${field}FileUrl`;
+        if (input[urlField] !== undefined) {
+            const bytes = await downloadSansanSource(String(input[urlField]), urlField, context);
+            form.append(part, new Blob([bytes], { type: "text/csv" }), `${field}.csv`);
+        }
+        else if (Array.isArray(input[field])) {
+            const rows = input[field].map((row) => requiredResponseRecord(row, "Sansan import row"));
+            const csv = [
+                columns.join(separator),
+                ...rows.map((row) => columns.map((column) => csvCell(row[column], separator)).join(separator)),
+            ].join("\r\n") + "\r\n";
+            form.append(part, new Blob([csv], { type: "text/csv; charset=utf-8" }), `${field}.csv`);
+        }
+    }
+    return encodeSansanMultipart(form);
+}
+function csvCell(value, separator) {
+    const text = value === undefined || value === null ? "" : String(value);
+    return [separator, '"', "\r", "\n"].some((character) => text.includes(character))
+        ? `"${text.split('"').join('""')}"`
+        : text;
+}

package/src/providers/sansan/read.d.ts

@@ -0,0 +1,2 @@
+import type { SansanContext } from "./request.ts";
+export declare function executeSansanRead(name: string, input: Record<string, unknown>, context: SansanContext): Promise<Record<string, unknown>>;

package/src/providers/sansan/read.js

@@ -0,0 +1,25 @@
+import { providerInputError } from "../provider-runtime.js";
+import { normalizeSansanPage, requestSansanJson, sansanPageQuery, sansanPathId } from "./request.js";
+const actionRoutes = {
+    get_current_user: { path: "/me" },
+    list_business_cards: { path: "/bizCards", list: true },
+    search_business_cards: { path: "/bizCards/search", list: true },
+    get_business_card: { path: "/bizCards/{id}", idField: "businessCardId" },
+    get_person: { path: "/persons/{id}", idField: "personId" },
+    list_business_card_tags: { path: "/bizCards/{id}/tags", idField: "businessCardId", list: true },
+    list_tags: { path: "/tags", list: true },
+    list_contact_reports: { path: "/reports", list: true },
+};
+export async function executeSansanRead(name, input, context) {
+    const route = actionRoutes[name];
+    if (!route)
+        throw providerInputError(`Unknown Sansan read action: ${name}`);
+    const query = { ...input };
+    let path = route.path;
+    if (route.idField) {
+        path = path.replace("{id}", sansanPathId(query[route.idField], route.idField));
+        delete query[route.idField];
+    }
+    const result = await requestSansanJson(path, { query: sansanPageQuery(query) }, context);
+    return route.list ? normalizeSansanPage(result) : result;
+}

package/src/providers/sansan/request.d.ts

@@ -0,0 +1,22 @@
+import type { ApiKeyProviderContext } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const sansanApiBaseUrl = "https://api.sansan.com/v6.0";
+export interface SansanContext extends ApiKeyProviderContext {
+    phase?: "validate" | "execute";
+}
+export type SansanActionHandler = (input: Record<string, unknown>, context: SansanContext) => Promise<unknown>;
+interface SansanRequest {
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    query?: Record<string, unknown>;
+    json?: unknown;
+    body?: BodyInit;
+    headers?: Record<string, string>;
+}
+export declare function requestSansan<T>(path: string, input: SansanRequest, context: SansanContext, consume: (response: Response) => Promise<T>): Promise<T>;
+export declare function requestSansanJson(path: string, input: SansanRequest, context: SansanContext): Promise<Record<string, unknown>>;
+export declare function readSansanJson(response: Response, allowEmpty?: boolean): Promise<unknown>;
+export declare function normalizeSansanPage(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function sansanPathId(value: unknown, field: string): string;
+export declare function sansanPageQuery(query: Record<string, unknown>): Record<string, unknown>;
+export declare function readSansanError(response: Response, phase?: "validate" | "execute"): Promise<ProviderRequestError>;
+export {};

package/src/providers/sansan/request.js

@@ -0,0 +1,94 @@
+import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const sansanApiBaseUrl = "https://api.sansan.com/v6.0";
+export async function requestSansan(path, input, context, consume) {
+    return runProviderRequest({ label: "Sansan", signal: context.signal }, async (signal) => {
+        const url = new URL(`${sansanApiBaseUrl}${path}`);
+        for (const [key, value] of Object.entries(input.query ?? {})) {
+            if (value === undefined)
+                continue;
+            if (Array.isArray(value)) {
+                const parameter = key === "tagIds" ? "tagId[]" : path === "/reports" ? `${key}[]` : key;
+                for (const item of value)
+                    url.searchParams.append(parameter, String(item));
+            }
+            else {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const headers = new Headers(input.headers);
+        headers.set("X-Sansan-Api-Key", context.apiKey);
+        headers.set("accept", "application/json, text/csv, image/jpeg");
+        headers.set("user-agent", providerUserAgent);
+        if (input.json !== undefined)
+            headers.set("content-type", "application/json");
+        const response = await context.fetcher(url, {
+            method: input.method ?? "GET",
+            headers,
+            body: input.json === undefined ? input.body : JSON.stringify(input.json),
+            signal,
+        });
+        if (!response.ok)
+            throw await readSansanError(response, context.phase ?? "execute");
+        return consume(response);
+    });
+}
+export function requestSansanJson(path, input, context) {
+    return requestSansan(path, input, context, async (response) => requiredResponseRecord(await readSansanJson(response), "Sansan response"));
+}
+export async function readSansanJson(response, allowEmpty = false) {
+    const text = await response.text();
+    if (allowEmpty && !text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw providerResponseError("Sansan returned invalid JSON");
+    }
+}
+export function normalizeSansanPage(payload) {
+    if (!Array.isArray(payload.data) || typeof payload.hasMore !== "boolean") {
+        throw providerResponseError("Sansan list response is missing data or hasMore");
+    }
+    const nextPageToken = optionalString(payload.nextPageToken) || null;
+    if (payload.hasMore && !nextPageToken) {
+        throw providerResponseError("Sansan list response is missing nextPageToken");
+    }
+    return { ...payload, data: payload.data, hasMore: payload.hasMore, nextPageToken };
+}
+export function sansanPathId(value, field) {
+    const id = optionalString(value)?.trim();
+    if (!id || id === "." || id === "..") {
+        throw providerInputError(`${field} must be a non-empty resource ID, not a dot path segment`);
+    }
+    return encodeURIComponent(id);
+}
+export function sansanPageQuery(query) {
+    const token = optionalString(query.nextPageToken);
+    return token ? { nextPageToken: token } : query;
+}
+export async function readSansanError(response, phase = "execute") {
+    const text = await response.text();
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        value = { message: text };
+    }
+    const payload = optionalRecord(value);
+    const codes = looseArray(payload?.error).flatMap((detail) => {
+        const item = optionalRecord(detail);
+        const code = optionalString(item?.Code) ?? optionalString(item?.code);
+        return code ? [code] : [];
+    });
+    const detail = optionalString(payload?.message) || `Sansan request failed with status ${response.status}`;
+    const message = codes.length ? `${detail} (${codes.join(", ")})` : detail;
+    if (codes.includes("invalid_api_key")) {
+        return new ProviderRequestError(phase === "validate" ? 400 : 409, message, undefined, phase === "validate" ? "invalid_input" : "authorization_failed");
+    }
+    if (response.status === 429)
+        return new ProviderRequestError(429, message, undefined, "rate_limited");
+    return new ProviderRequestError(response.status, message, undefined, "provider_error");
+}

package/src/providers/sansan/schemas.d.ts

@@ -0,0 +1,7 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const businessCardSchema: JsonSchema;
+export declare const userSchema: JsonSchema;
+export declare const reportSchema: JsonSchema;
+export declare const businessCardPageSchema: JsonSchema;
+export declare const tagPageSchema: JsonSchema;
+export declare const reportPageSchema: JsonSchema;

package/src/providers/sansan/schemas.js

@@ -0,0 +1,72 @@
+import { s } from "../../core/json-schema.js";
+const ownerSchema = s.object("The business card or tag owner.", {
+    id: s.string("The owner user ID."),
+    name: s.string("The owner name."),
+    email: s.string("The owner email address."),
+}, { additionalProperties: true, required: [] });
+const tagSchema = s.object("A Sansan tag, with additional upstream fields preserved.", {
+    id: s.string("The tag ID."),
+    name: s.string("The tag name."),
+    type: s.string("The tag visibility: private, public, or shared."),
+    owner: ownerSchema,
+}, { additionalProperties: true, required: [] });
+export const businessCardSchema = s.object("A business card with contact details; additional Sansan fields are preserved.", {
+    id: s.nullable(s.string("The business card ID.")),
+    companyId: s.nullable(s.string("The company ID.")),
+    personId: s.nullable(s.string("The person ID.")),
+    firstName: s.nullable(s.string("The first name.")),
+    lastName: s.nullable(s.string("The last name.")),
+    companyName: s.nullable(s.string("The company name.")),
+    departmentName: s.nullable(s.string("The department name.")),
+    title: s.nullable(s.string("The job title.")),
+    email: s.nullable(s.string("The email address.")),
+    tel: s.nullable(s.string("The telephone number.")),
+    mobile: s.nullable(s.string("The mobile phone number.")),
+    exchangeDate: s.nullable(s.string("The business card exchange date.")),
+    registeredTime: s.nullable(s.string("The registration timestamp.")),
+    updatedTime: s.nullable(s.string("The last update timestamp.")),
+    entryStatus: s.nullable(s.string("The digitization status.")),
+    owner: ownerSchema,
+    tags: s.array("Tags attached to the business card when requested.", tagSchema),
+}, { additionalProperties: true, required: [] });
+export const userSchema = s.object("The Sansan user associated with the API key.", {
+    id: s.string("The user ID."),
+    name: s.string("The user name."),
+    userType: s.string("The user role in Sansan."),
+    canUpdateData: s.boolean("Whether the user can update all data."),
+    departments: s.array("Departments the user belongs to.", s.object("A user department.", {
+        name: s.string("The department name."),
+    }, { additionalProperties: true, required: [] })),
+}, { additionalProperties: true, required: [] });
+export const reportSchema = s.object("A contact report with meeting or communication details and additional upstream fields.", {
+    id: s.string("Contact report ID."),
+    registeredTime: s.string("Contact report registration timestamp."),
+    updatedTime: s.string("Contact report update timestamp."),
+    startDate: s.string("Interaction start date."),
+    endDate: s.string("Interaction end date."),
+    startTime: s.string("Interaction start timestamp."),
+    endTime: s.string("Interaction end timestamp."),
+    type: s.string("Recorded interaction type."),
+    title: s.string("Contact report title."),
+    location: s.string("Contact location."),
+    memo: s.string("Contact report memo."),
+    owner: ownerSchema,
+    externalAttendees: s.array("External attendees and their business card and person IDs.", s.unknownObject("An external participant with provider-defined contact fields.")),
+    internalAttendees: s.array("Internal attendees and their user details.", s.unknownObject("An internal participant with provider-defined user fields.")),
+    categories: s.array("Categories assigned to the contact report.", s.unknownObject("A category name and value.")),
+}, { additionalProperties: true, required: [] });
+export const businessCardPageSchema = s.object("One page of Sansan records.", {
+    data: s.array("Records in this page.", businessCardSchema),
+    hasMore: s.boolean("Whether another page is available."),
+    nextPageToken: s.nullable(s.string("The next page token, or null when absent. Tokens expire six hours after the first request.")),
+}, { additionalProperties: true, required: ["data", "hasMore", "nextPageToken"] });
+export const tagPageSchema = s.object("One page of Sansan records.", {
+    data: s.array("Records in this page.", tagSchema),
+    hasMore: s.boolean("Whether another page is available."),
+    nextPageToken: s.nullable(s.string("The next page token, or null when absent. Tokens expire six hours after the first request.")),
+}, { additionalProperties: true, required: ["data", "hasMore", "nextPageToken"] });
+export const reportPageSchema = s.object("One page of Sansan records.", {
+    data: s.array("Records in this page.", reportSchema),
+    hasMore: s.boolean("Whether another page is available."),
+    nextPageToken: s.nullable(s.string("The next page token, or null when absent. Tokens expire six hours after the first request.")),
+}, { additionalProperties: true, required: ["data", "hasMore", "nextPageToken"] });

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

@@ -0,0 +1,17 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface SaperlyEndpoint {
+    name: string;
+    method: "GET" | "POST" | "PATCH" | "DELETE";
+    path: string;
+    pathKeys: string[];
+    queryKeys: string[];
+    outputKind: "object" | "list" | "recording" | "transcript";
+    operationType: ActionDefinition["operationType"];
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+declare const saperlyEndpoints: SaperlyEndpoint[];
+export declare const saperlyActions: ActionDefinition[];
+export declare const saperlyEndpointByName: Map<string, (typeof saperlyEndpoints)[number]>;
+export {};