@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/smarthr/pagination.js

@@ -0,0 +1,84 @@
+function splitLinkParts(value, delimiter) {
+    const parts = [];
+    let start = 0;
+    let inTarget = false;
+    let inQuotes = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index++) {
+        const character = value[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inQuotes && character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (!inTarget && character === '"')
+            inQuotes = !inQuotes;
+        if (!inQuotes) {
+            if (character === "<")
+                inTarget = true;
+            else if (character === ">")
+                inTarget = false;
+            else if (!inTarget && character === delimiter) {
+                parts.push(value.slice(start, index));
+                start = index + 1;
+            }
+        }
+    }
+    parts.push(value.slice(start));
+    return parts;
+}
+function parameterValue(value) {
+    if (!value.startsWith('"'))
+        return value;
+    let result = "";
+    for (let index = 1; index < value.length; index++) {
+        const character = value[index];
+        if (character === '"')
+            return index === value.length - 1 ? result : undefined;
+        if (character === "\\") {
+            index++;
+            if (index === value.length)
+                return undefined;
+        }
+        result += value[index];
+    }
+    return undefined;
+}
+export function readSmartHrNextPage(headers, requestUrl) {
+    for (const entry of splitLinkParts(headers.get("link") ?? "", ",")) {
+        const link = entry.trim();
+        const targetEnd = link.indexOf(">");
+        if (!link.startsWith("<") || targetEnd < 1)
+            continue;
+        const parameters = new Map();
+        const suffix = link.slice(targetEnd + 1).trim();
+        if (suffix && !suffix.startsWith(";"))
+            continue;
+        for (const part of splitLinkParts(suffix, ";")) {
+            const separator = part.indexOf("=");
+            const name = (separator < 0 ? part : part.slice(0, separator)).trim().toLowerCase();
+            if (!name || parameters.has(name))
+                continue;
+            parameters.set(name, separator < 0 ? undefined : parameterValue(part.slice(separator + 1).trim()));
+        }
+        if (parameters.has("anchor"))
+            continue;
+        const relations = parameters.get("rel")?.toLowerCase().split(" ");
+        if (!relations?.includes("next"))
+            continue;
+        try {
+            const url = new URL(link.slice(1, targetEnd), requestUrl);
+            const page = url.searchParams.get("page");
+            if (!page || [...page].some((character) => !"0123456789".includes(character)))
+                continue;
+            const value = Number(page);
+            if (Number.isSafeInteger(value) && value > 0)
+                return value;
+        }
+        catch { }
+    }
+    return null;
+}

package/src/providers/smarthr/resource-routes.d.ts

@@ -0,0 +1,16 @@
+export declare const supplementalListRoutes: Record<string, {
+    path: string;
+    key: string;
+}>;
+export declare const supplementalGetRoutes: Record<string, {
+    path: string;
+    key: string;
+    id: string;
+}>;
+export declare const masterWriteRoutes: Record<string, {
+    path: string;
+    key: string;
+    id: string;
+    method: string;
+    fields: string[];
+}>;

package/src/providers/smarthr/resource-routes.js

@@ -0,0 +1,163 @@
+export const supplementalListRoutes = {
+    list_job_titles: { path: "job_titles", key: "jobTitles" },
+    list_grades: { path: "grades", key: "grades" },
+    list_job_categories: { path: "job_categories", key: "jobCategories" },
+    list_recruitment_types: { path: "recruitment_types", key: "recruitmentTypes" },
+    list_users: { path: "users", key: "users" },
+    list_employee_input_forms: { path: "crew_input_forms", key: "employeeInputForms" },
+    list_payment_periods: { path: "payment_periods", key: "paymentPeriods" },
+    list_bank_account_settings: { path: "bank_account_settings", key: "bankAccountSettings" },
+};
+export const supplementalGetRoutes = {
+    get_job_title: { path: "job_titles", key: "jobTitle", id: "jobTitleId" },
+    get_grade: { path: "grades", key: "grade", id: "gradeId" },
+    get_job_category: { path: "job_categories", key: "jobCategory", id: "jobCategoryId" },
+    get_recruitment_type: {
+        path: "recruitment_types",
+        key: "recruitmentType",
+        id: "recruitmentTypeId",
+    },
+    get_user: { path: "users", key: "user", id: "userId" },
+    get_employee_input_form: {
+        path: "crew_input_forms",
+        key: "employeeInputForm",
+        id: "employeeInputFormId",
+    },
+    get_payment_period: { path: "payment_periods", key: "paymentPeriod", id: "paymentPeriodId" },
+};
+export const masterWriteRoutes = {
+    create_employment_type: {
+        path: "employment_types",
+        key: "employmentType",
+        id: "employmentTypeId",
+        method: "POST",
+        fields: ["name", "code"],
+    },
+    update_employment_type: {
+        path: "employment_types",
+        key: "employmentType",
+        id: "employmentTypeId",
+        method: "PATCH",
+        fields: ["name", "code"],
+    },
+    replace_employment_type: {
+        path: "employment_types",
+        key: "employmentType",
+        id: "employmentTypeId",
+        method: "PUT",
+        fields: ["name"],
+    },
+    delete_employment_type: {
+        path: "employment_types",
+        key: "employmentType",
+        id: "employmentTypeId",
+        method: "DELETE",
+        fields: [],
+    },
+    create_job_title: {
+        path: "job_titles",
+        key: "jobTitle",
+        id: "jobTitleId",
+        method: "POST",
+        fields: ["name", "rank", "code"],
+    },
+    update_job_title: {
+        path: "job_titles",
+        key: "jobTitle",
+        id: "jobTitleId",
+        method: "PATCH",
+        fields: ["name", "rank", "code"],
+    },
+    replace_job_title: {
+        path: "job_titles",
+        key: "jobTitle",
+        id: "jobTitleId",
+        method: "PUT",
+        fields: ["name", "rank"],
+    },
+    delete_job_title: {
+        path: "job_titles",
+        key: "jobTitle",
+        id: "jobTitleId",
+        method: "DELETE",
+        fields: [],
+    },
+    create_grade: {
+        path: "grades",
+        key: "grade",
+        id: "gradeId",
+        method: "POST",
+        fields: ["name", "rank"],
+    },
+    update_grade: {
+        path: "grades",
+        key: "grade",
+        id: "gradeId",
+        method: "PATCH",
+        fields: ["name", "rank"],
+    },
+    replace_grade: {
+        path: "grades",
+        key: "grade",
+        id: "gradeId",
+        method: "PUT",
+        fields: ["name", "rank"],
+    },
+    delete_grade: { path: "grades", key: "grade", id: "gradeId", method: "DELETE", fields: [] },
+    create_job_category: {
+        path: "job_categories",
+        key: "jobCategory",
+        id: "jobCategoryId",
+        method: "POST",
+        fields: ["name"],
+    },
+    update_job_category: {
+        path: "job_categories",
+        key: "jobCategory",
+        id: "jobCategoryId",
+        method: "PATCH",
+        fields: ["name"],
+    },
+    replace_job_category: {
+        path: "job_categories",
+        key: "jobCategory",
+        id: "jobCategoryId",
+        method: "PUT",
+        fields: ["name"],
+    },
+    delete_job_category: {
+        path: "job_categories",
+        key: "jobCategory",
+        id: "jobCategoryId",
+        method: "DELETE",
+        fields: [],
+    },
+    create_recruitment_type: {
+        path: "recruitment_types",
+        key: "recruitmentType",
+        id: "recruitmentTypeId",
+        method: "POST",
+        fields: ["name"],
+    },
+    update_recruitment_type: {
+        path: "recruitment_types",
+        key: "recruitmentType",
+        id: "recruitmentTypeId",
+        method: "PATCH",
+        fields: ["name"],
+    },
+    replace_recruitment_type: {
+        path: "recruitment_types",
+        key: "recruitmentType",
+        id: "recruitmentTypeId",
+        method: "PUT",
+        fields: ["name"],
+    },
+    delete_recruitment_type: {
+        path: "recruitment_types",
+        key: "recruitmentType",
+        id: "recruitmentTypeId",
+        method: "DELETE",
+        fields: [],
+    },
+};

package/src/providers/smarthr/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { ApiKeyActionRequest } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare function smartHrBaseUrl(metadata: Record<string, unknown>): string;
+export declare function validateSmartHrCredential(input: Record<string, string>, fetcher: typeof fetch, signal?: AbortSignal): Promise<{
+    accountId: string;
+    displayName: string;
+    tenant: {
+        subdomain: string;
+        environment: string;
+    };
+}>;
+export declare function executeSmartHrAction(input: ApiKeyActionRequest, fetcher: typeof fetch, signal?: AbortSignal): Promise<Record<string, unknown>>;
+export declare function readSmartHrError(response: Response): Promise<ProviderRequestError>;

package/src/providers/smarthr/runtime.js

@@ -0,0 +1,242 @@
+import { optionalNumber, optionalRecord, optionalRawString } from "../../core/cast.js";
+import { ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { prepareEmployeeWrite } from "./employee-runtime.js";
+import { readSmartHrNextPage } from "./pagination.js";
+import { supplementalGetRoutes, supplementalListRoutes, masterWriteRoutes } from "./resource-routes.js";
+function readSmartHrTenant(metadata) {
+    const subdomain = requiredInputString(metadata.subdomain, "subdomain").toLowerCase();
+    const allowed = "abcdefghijklmnopqrstuvwxyz0123456789-";
+    if (subdomain.length > 63 ||
+        subdomain.startsWith("-") ||
+        subdomain.endsWith("-") ||
+        [...subdomain].some((character) => !allowed.includes(character))) {
+        throw new ProviderRequestError(400, "subdomain must be a SmartHR tenant subdomain, not a URL", undefined, "invalid_input");
+    }
+    const environment = optionalRawString(metadata.environment) ?? "production";
+    if (environment !== "production" && environment !== "sandbox") {
+        throw new ProviderRequestError(400, "environment must be production or sandbox", undefined, "invalid_input");
+    }
+    return { subdomain, environment };
+}
+export function smartHrBaseUrl(metadata) {
+    const tenant = readSmartHrTenant(metadata);
+    return `https://${tenant.subdomain}.${tenant.environment === "sandbox" ? "daruma.space" : "smarthr.jp"}/api`;
+}
+async function requestSmartHr(options) {
+    const url = new URL(`${smartHrBaseUrl(options.metadata)}${options.path}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value !== undefined)
+            url.searchParams.set(key, Array.isArray(value) ? value.join(",") : String(value));
+    }
+    const apiKey = requiredInputString(options.apiKey, "Access Token");
+    return runProviderRequest({ label: "SmartHR", signal: options.signal }, async (signal) => {
+        const response = await options.fetcher(url, {
+            method: options.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${apiKey}`,
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal,
+        });
+        if (!response.ok) {
+            throw await readSmartHrError(response);
+        }
+        return {
+            data: response.status === 204 ? null : await response.json(),
+            headers: response.headers,
+            requestUrl: url,
+        };
+    });
+}
+export async function validateSmartHrCredential(input, fetcher, signal) {
+    const tenant = readSmartHrTenant(input);
+    const { data } = await requestSmartHr({
+        apiKey: input.apiKey ?? "",
+        metadata: tenant,
+        path: "/v1/companies",
+        query: { page: 1, per_page: 1 },
+        signal,
+        fetcher,
+    });
+    if (!Array.isArray(data))
+        throw new ProviderRequestError(502, "SmartHR companies response must be an array", undefined, "provider_error");
+    const company = optionalRecord(data[0]);
+    return {
+        accountId: `${tenant.environment}:${tenant.subdomain}`,
+        displayName: optionalRawString(company?.name) ?? new URL(smartHrBaseUrl(tenant)).hostname,
+        tenant,
+    };
+}
+const listRoutes = {
+    ...supplementalListRoutes,
+    list_employees: { path: "crews", key: "employees" },
+    list_companies: { path: "companies", key: "companies" },
+    list_departments: { path: "departments", key: "departments" },
+    list_employment_types: { path: "employment_types", key: "employmentTypes" },
+    list_custom_fields: { path: "crew_custom_field_templates", key: "customFields" },
+    list_custom_field_groups: { path: "crew_custom_field_template_groups", key: "customFieldGroups" },
+    list_business_establishments: { path: "biz_establishments", key: "businessEstablishments" },
+};
+const getRoutes = {
+    ...supplementalGetRoutes,
+    get_employee: { path: "crews", key: "employee", id: "employeeId" },
+    get_department: { path: "departments", key: "department", id: "departmentId" },
+    get_employment_type: { path: "employment_types", key: "employmentType", id: "employmentTypeId" },
+};
+const employeeQueryNames = {
+    employeeCode: "emp_code",
+    employmentTypeIds: "employment_type_id",
+    employmentStatus: "emp_status",
+    gender: "gender",
+    sort: "sort",
+    enteredAtFrom: "entered_at_from",
+    enteredAtTo: "entered_at_to",
+    resignedAtFrom: "resigned_at_from",
+    resignedAtTo: "resigned_at_to",
+    userIds: "user_id",
+    departmentIds: "department_id",
+    positionIds: "position_id",
+    query: "q",
+    preferBusinessName: "prefer_business_name",
+    employeeIds: "id",
+    fields: "fields",
+};
+function pathId(value, name) {
+    const id = requiredInputString(value, name);
+    if (id === "." || id === "..")
+        throw new ProviderRequestError(400, `${name} must not be a dot path segment`, undefined, "invalid_input");
+    return encodeURIComponent(id);
+}
+export async function executeSmartHrAction(input, fetcher, signal) {
+    const values = input.input;
+    const common = { apiKey: input.apiKey, metadata: input.providerMetadata ?? {}, fetcher, signal };
+    const list = listRoutes[input.actionName];
+    if (list) {
+        const query = {
+            page: values.page ?? 1,
+            per_page: values.perPage ?? 10,
+        };
+        if (input.actionName === "list_employees") {
+            for (const [key, upstream] of Object.entries(employeeQueryNames))
+                query[upstream] = values[key];
+        }
+        else {
+            query.embed = values.embed;
+            query.code = values.code;
+            query.sort = values.sort;
+        }
+        const { data, headers, requestUrl } = await requestSmartHr({
+            ...common,
+            path: `/v1/${list.path}`,
+            query,
+        });
+        if (!Array.isArray(data))
+            throw new ProviderRequestError(502, "SmartHR list response must be an array", undefined, "provider_error");
+        const count = headers.get("x-total-count");
+        const total = count === null || count.trim() === "" ? NaN : Number(count);
+        return {
+            [list.key]: data,
+            page: query.page,
+            perPage: query.per_page,
+            totalCount: Number.isInteger(total) && total >= 0 ? total : null,
+            nextPage: readSmartHrNextPage(headers, requestUrl),
+        };
+    }
+    const get = getRoutes[input.actionName];
+    if (get) {
+        const { data } = await requestSmartHr({
+            ...common,
+            path: `/v1/${get.path}/${pathId(values[get.id], get.id)}`,
+            query: { fields: values.fields, embed: values.embed },
+        });
+        return { [get.key]: requiredResponseRecord(data, "SmartHR resource response") };
+    }
+    const master = masterWriteRoutes[input.actionName];
+    if (master) {
+        const resourcePath = `/v1/${master.path}${master.method === "POST" ? "" : `/${pathId(values[master.id], master.id)}`}`;
+        const body = master.method === "DELETE"
+            ? undefined
+            : Object.fromEntries(master.fields.filter((field) => values[field] !== undefined).map((field) => [field, values[field]]));
+        const { data } = await requestSmartHr({
+            ...common,
+            method: master.method,
+            path: resourcePath,
+            body,
+        });
+        return master.method === "DELETE"
+            ? { deleted: true }
+            : { [master.key]: requiredResponseRecord(data, "SmartHR master data response") };
+    }
+    if (input.actionName === "create_employee" || input.actionName === "update_employee") {
+        const creating = input.actionName === "create_employee";
+        const employeePath = `/v1/crews${creating ? "" : `/${pathId(values.employeeId, "employeeId")}`}`;
+        readSmartHrTenant(common.metadata);
+        requiredInputString(common.apiKey, "Access Token");
+        const body = await prepareEmployeeWrite(values.employee, fetcher, signal);
+        const { data } = await requestSmartHr({
+            ...common,
+            method: creating ? "POST" : "PATCH",
+            path: employeePath,
+            body,
+        });
+        return { employee: requiredResponseRecord(data, "SmartHR employee response") };
+    }
+    if (["delete_employee", "clear_employee_departments", "invite_employee"].includes(input.actionName)) {
+        const employeePath = `/v1/crews/${pathId(values.employeeId, "employeeId")}`;
+        const inviting = input.actionName === "invite_employee";
+        const clearing = input.actionName === "clear_employee_departments";
+        await requestSmartHr({
+            ...common,
+            method: inviting ? "PUT" : "DELETE",
+            path: `${employeePath}${inviting ? "/invite" : clearing ? "/departments" : ""}`,
+            body: inviting
+                ? { inviter_user_id: values.inviterUserId, crew_input_form_id: values.employeeInputFormId }
+                : undefined,
+        });
+        return inviting ? { invited: true } : clearing ? { cleared: true } : { deleted: true };
+    }
+    const departmentId = input.actionName === "create_department" ? undefined : pathId(values.departmentId, "departmentId");
+    if (input.actionName === "discontinue_department") {
+        await requestSmartHr({
+            ...common,
+            method: "POST",
+            path: `/v1/departments/${departmentId}/discontinue`,
+            body: { discontinued_date: values.discontinuedDate },
+        });
+        return { discontinued: true };
+    }
+    const methods = {
+        create_department: "POST",
+        update_department: "PATCH",
+        replace_department: "PUT",
+    };
+    const method = methods[input.actionName];
+    if (!method)
+        throw new ProviderRequestError(400, `unknown smarthr action: ${input.actionName}`, undefined, "invalid_input");
+    const { data } = await requestSmartHr({
+        ...common,
+        method,
+        path: `/v1/departments${departmentId === undefined ? "" : `/${departmentId}`}`,
+        body: {
+            name: values.name,
+            code: values.code,
+            position: values.position,
+            company_id: values.companyId,
+            parent_id: values.parentId,
+        },
+    });
+    return { department: requiredResponseRecord(data, "SmartHR department response") };
+}
+export async function readSmartHrError(response) {
+    const error = optionalRecord(await response.json().catch(() => undefined));
+    const code = optionalNumber(error?.code);
+    const type = optionalRawString(error?.type);
+    const message = optionalRawString(error?.message) ?? `SmartHR request failed with status ${response.status}`;
+    const detail = `${message}${code === undefined ? "" : ` (code: ${code})`}${type ? ` [${type}]` : ""}`;
+    const invalidToken = code === 2 || type === "unauthorized_token";
+    return new ProviderRequestError(response.status, detail, error?.errors === undefined ? undefined : { errors: error.errors }, invalidToken ? "authorization_failed" : "provider_error");
+}

package/src/providers/smarthr/supplemental-actions.d.ts

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