@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/shopify/{runtime.js → content-runtime.js}

@@ -1,15 +1,6 @@
-import { compactObject, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
-import { assertPublicHttpUrl } from "../../core/request.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
-export const shopifyRestApiVersion = "2026-04";
-const credentialHelpUrl = "https://shopify.dev/docs/apps/build/authentication-authorization/access-tokens";
-const shopPath = "/shop.json";
-export const shopifyActionHandlers = {
-    async get_shop(_input, context) {
-        return {
-            shop: await getShopifyResource(context, shopPath, "shop"),
-        };
-    },
+import { ProviderRequestError, requiredResponseRecord } from "../provider-runtime.js";
+import { buildShopifyApiBaseUrl, requestShopifyJson } from "./client.js";
+export const contentActionHandlers = {
     list_blogs(input, context) {
         return listShopifyResources(input, context, {
             path: "/blogs.json",
@@ -113,9 +104,8 @@ export const shopifyActionHandlers = {
             context,
             path: "/articles/tags.json",
             query: buildArticleTagQuery(input),
-            phase: "execute",
         });
-        const record = requireRecord(payload, "Shopify article tags response");
+        const record = requiredResponseRecord(payload, "Shopify article tags response");
         return {
             tags: requireStringArray(record.tags, "tags"),
         };
@@ -125,9 +115,8 @@ export const shopifyActionHandlers = {
             context,
             path: `/blogs/${readId(input, "blog_id")}/articles/tags.json`,
             query: buildArticleTagQuery(input),
-            phase: "execute",
         });
-        const record = requireRecord(payload, "Shopify blog article tags response");
+        const record = requiredResponseRecord(payload, "Shopify blog article tags response");
         return {
             tags: requireStringArray(record.tags, "tags"),
         };
@@ -136,51 +125,19 @@ export const shopifyActionHandlers = {
         const { payload } = await requestShopifyRest({
             context,
             path: "/articles/authors.json",
-            phase: "execute",
         });
-        const record = requireRecord(payload, "Shopify article authors response");
+        const record = requiredResponseRecord(payload, "Shopify article authors response");
         return {
             authors: requireStringArray(record.authors, "authors"),
         };
     },
 };
-export async function validateShopifyCredential(accessToken, shopDomain, grantedScopes, fetcher, signal) {
-    const context = {
-        accessToken,
-        shopDomain,
-        fetcher,
-        signal,
-    };
-    const shopResult = await requestShopifyRest({
-        context,
-        path: shopPath,
-        phase: "validate",
-    });
-    const shop = requireRecord(requireRecord(shopResult.payload, "Shopify shop response").shop, "shop");
-    return {
-        profile: {
-            accountId: `shopify:${shopDomain}`,
-            displayName: optionalString(shop.name) ?? shopDomain,
-        },
-        grantedScopes,
-        metadata: compactObject({
-            shopDomain,
-            apiBaseUrl: buildShopifyRestApiBaseUrl(shopDomain),
-            restApiVersion: shopifyRestApiVersion,
-            credentialHelpUrl,
-            validationEndpoint: shopPath,
-            shopId: optionalNumber(shop.id),
-            myshopifyDomain: optionalString(shop.myshopify_domain),
-        }),
-    };
-}
 async function getShopifyResource(context, path, resultKey) {
     const { payload } = await requestShopifyRest({
         context,
         path,
-        phase: "execute",
     });
-    return requireRecord(requireRecord(payload, `Shopify ${resultKey} response`)[resultKey], resultKey);
+    return requiredResponseRecord(requiredResponseRecord(payload, `Shopify ${resultKey} response`)[resultKey], resultKey);
 }
 async function listShopifyResources(input, context, options) {
     assertPageInfoFilterBoundary(input);
@@ -188,9 +145,8 @@ async function listShopifyResources(input, context, options) {
         context,
         path: options.path,
         query: pickQuery(input, options.queryKeys),
-        phase: "execute",
     });
-    const record = requireRecord(payload, `Shopify ${options.resultKey} response`);
+    const record = requiredResponseRecord(payload, `Shopify ${options.resultKey} response`);
     return {
         [options.resultKey]: requireRecordArray(record[options.resultKey], options.resultKey),
         pagination,
@@ -202,159 +158,18 @@ async function countShopifyResources(input, context, options) {
         context,
         path: options.path,
         query: pickQuery(input, options.queryKeys),
-        phase: "execute",
     });
-    const record = requireRecord(payload, "Shopify count response");
+    const record = requiredResponseRecord(payload, "Shopify count response");
     return {
         count: readCount(record.count),
     };
 }
 async function requestShopifyRest(input) {
-    const url = buildShopifyRestUrl(input.context.shopDomain, input.path, input.query);
-    let response;
-    let payload;
-    try {
-        response = await input.context.fetcher(url, {
-            method: "GET",
-            headers: {
-                accept: "application/json",
-                "user-agent": providerUserAgent,
-                "x-shopify-access-token": input.context.accessToken,
-            },
-            signal: input.context.signal,
-        });
-        payload = await readShopifyPayload(response);
-    }
-    catch (error) {
-        if (error instanceof ProviderRequestError) {
-            throw error;
-        }
-        throw new ProviderRequestError(502, error instanceof Error ? `Shopify REST request failed: ${error.message}` : "Shopify REST request failed");
-    }
-    if (!response.ok) {
-        throw createShopifyRestError(response, payload, input.phase);
-    }
-    return {
-        payload,
-        pagination: readPagination(response.headers.get("link")),
-    };
-}
-export function buildShopifyRestApiBaseUrl(shopDomain) {
-    return `https://${shopDomain}/admin/api/${shopifyRestApiVersion}`;
-}
-function buildShopifyRestUrl(shopDomain, path, query) {
-    const url = assertPublicHttpUrl(new URL(path.startsWith("/") ? path.slice(1) : path, `${buildShopifyRestApiBaseUrl(shopDomain)}/`).toString(), {
-        fieldName: "shopDomain",
-        createError: (message) => new ProviderRequestError(400, message),
-    });
-    for (const [key, value] of Object.entries(query ?? {})) {
+    const url = new URL(input.path.slice(1), buildShopifyApiBaseUrl(input.context.shopDomain) + "/");
+    for (const [key, value] of Object.entries(input.query ?? {}))
         url.searchParams.set(key, value);
-    }
-    return url;
-}
-export function normalizeShopDomain(value) {
-    if (!value) {
-        throw new ProviderRequestError(400, "shopDomain is required");
-    }
-    const trimmed = value.trim();
-    let host = trimmed;
-    if (trimmed.includes("://")) {
-        let url;
-        try {
-            url = new URL(trimmed);
-        }
-        catch {
-            throw new ProviderRequestError(400, "shopDomain must be a myshopify.com domain or URL");
-        }
-        host = url.hostname;
-    }
-    else {
-        host = trimmed.split("/")[0] ?? "";
-    }
-    const normalized = host.toLowerCase();
-    if (!isMyshopifyDomain(normalized)) {
-        throw new ProviderRequestError(400, "shopDomain must be a myshopify.com domain or URL");
-    }
-    return normalized;
-}
-function isMyshopifyDomain(host) {
-    if (!host.endsWith(".myshopify.com") || host.length <= ".myshopify.com".length) {
-        return false;
-    }
-    return host
-        .slice(0, -".myshopify.com".length)
-        .split(".")
-        .every((segment) => isDnsLabel(segment));
-}
-function isDnsLabel(value) {
-    if (!value || value.startsWith("-") || value.endsWith("-") || value.length > 63) {
-        return false;
-    }
-    for (const char of value) {
-        const code = char.charCodeAt(0);
-        const isDigit = code >= 48 && code <= 57;
-        const isLowercaseLetter = code >= 97 && code <= 122;
-        if (!isDigit && !isLowercaseLetter && char !== "-") {
-            return false;
-        }
-    }
-    return true;
-}
-async function readShopifyPayload(response) {
-    const text = await response.text();
-    if (!text.trim()) {
-        return null;
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        if (response.ok) {
-            throw new ProviderRequestError(502, "Shopify REST returned invalid JSON", text);
-        }
-        return text;
-    }
-}
-function createShopifyRestError(response, payload, phase) {
-    const detail = extractShopifyErrorMessage(payload);
-    const message = detail
-        ? `Shopify REST request failed with HTTP ${response.status}: ${detail}`
-        : `Shopify REST request failed with HTTP ${response.status}`;
-    if (phase === "validate" && isCredentialValidationStatus(response.status)) {
-        return new ProviderRequestError(400, message, payload);
-    }
-    if (response.status === 401 || response.status === 403) {
-        return new ProviderRequestError(response.status, message, payload);
-    }
-    if (response.status === 400 || response.status === 404 || response.status === 422) {
-        return new ProviderRequestError(response.status, message, payload);
-    }
-    return new ProviderRequestError(response.status || 502, message, payload);
-}
-function isCredentialValidationStatus(status) {
-    return status === 401 || status === 403 || status === 404;
-}
-function extractShopifyErrorMessage(payload) {
-    if (typeof payload === "string") {
-        return payload.trim() || undefined;
-    }
-    const record = optionalRecord(payload);
-    if (!record) {
-        return undefined;
-    }
-    const errors = record.errors;
-    if (typeof errors === "string") {
-        return errors;
-    }
-    if (Array.isArray(errors)) {
-        return errors.map((item) => String(item)).join("; ");
-    }
-    if (optionalRecord(errors)) {
-        return Object.entries(errors)
-            .map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : String(value)}`)
-            .join("; ");
-    }
-    return optionalString(record.error) ?? optionalString(record.message);
+    const { response, payload } = await requestShopifyJson(input.context.shopDomain, input.context.accessToken, url, { method: "GET", signal: input.context.signal }, input.context.fetcher);
+    return { payload, pagination: readPagination(response.headers.get("link")) };
 }
 function pickQuery(input, keys) {
     const query = {};
@@ -440,18 +255,11 @@ function readCount(value) {
     }
     return value;
 }
-function requireRecord(value, fieldName) {
-    const record = optionalRecord(value);
-    if (!record) {
-        throw new ProviderRequestError(502, `${fieldName} is missing`);
-    }
-    return record;
-}
 function requireRecordArray(value, fieldName) {
     if (!Array.isArray(value)) {
         throw new ProviderRequestError(502, `${fieldName} array is missing`);
     }
-    return value.map((item) => requireRecord(item, fieldName));
+    return value.map((item) => requiredResponseRecord(item, fieldName));
 }
 function requireStringArray(value, fieldName) {
     if (!Array.isArray(value)) {

package/src/providers/shopify/context.d.ts

@@ -0,0 +1,10 @@
+import type { TransitFileWriter } from "../../core/types.ts";
+import type { ProviderRuntimeHandler } from "../provider-runtime.ts";
+export interface ShopifyContext {
+    accessToken: string;
+    shopDomain: string;
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+    transitFiles?: TransitFileWriter;
+}
+export type ShopifyActionHandler = ProviderRuntimeHandler<ShopifyContext>;

package/src/providers/shopify/context.js

@@ -0,0 +1 @@
+export {};

package/src/providers/shopify/customers.d.ts

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

package/src/providers/shopify/customers.js

@@ -0,0 +1,118 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { requiredResponseRecord } from "../provider-runtime.js";
+import { requestShopifyGraphQL } from "./client.js";
+import { connectionVariables, normalizePageInfo, readEdges, readNullableObject, readRequiredString, } from "./runtime-common.js";
+const listCustomersQuery = `query ShopifyListCustomers($first: Int, $after: String, $query: String) {
+  customers(first: $first, after: $after, query: $query) {
+    edges {
+      cursor
+      node {
+        id
+        displayName
+        firstName
+        lastName
+        defaultEmailAddress {
+          emailAddress
+        }
+        defaultPhoneNumber {
+          phoneNumber
+        }
+        state
+        tags
+        numberOfOrders
+        amountSpent {
+          amount
+          currencyCode
+        }
+        createdAt
+        updatedAt
+      }
+    }
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+  }
+}`;
+const getCustomerQuery = `query ShopifyGetCustomer($id: ID!) {
+  customer(id: $id) {
+    id
+    displayName
+    firstName
+    lastName
+    defaultEmailAddress {
+      emailAddress
+    }
+    defaultPhoneNumber {
+      phoneNumber
+    }
+    state
+    tags
+    numberOfOrders
+    amountSpent {
+      amount
+      currencyCode
+    }
+    createdAt
+    updatedAt
+  }
+}`;
+function normalizeCustomer(edge) {
+    const customer = requiredResponseRecord(edge.node, "node");
+    return {
+        ...normalizeCustomerDetail(customer),
+        cursor: optionalString(edge.cursor) ?? null,
+    };
+}
+function normalizeCustomerDetail(raw) {
+    const amountSpent = optionalRecord(raw.amountSpent);
+    const defaultEmailAddress = optionalRecord(raw.defaultEmailAddress);
+    const defaultPhoneNumber = optionalRecord(raw.defaultPhoneNumber);
+    return {
+        id: readRequiredString(raw, "id"),
+        displayName: readRequiredString(raw, "displayName"),
+        firstName: optionalString(raw.firstName) ?? null,
+        lastName: optionalString(raw.lastName) ?? null,
+        email: optionalString(defaultEmailAddress?.emailAddress) ?? null,
+        phone: optionalString(defaultPhoneNumber?.phoneNumber) ?? null,
+        state: optionalString(raw.state) ?? null,
+        tags: readStringArray(raw.tags),
+        numberOfOrders: optionalString(raw.numberOfOrders) ?? null,
+        amountSpent: optionalString(amountSpent?.amount) ?? null,
+        amountSpentCurrencyCode: optionalString(amountSpent?.currencyCode) ?? null,
+        createdAt: optionalString(raw.createdAt) ?? null,
+        updatedAt: optionalString(raw.updatedAt) ?? null,
+        raw,
+    };
+}
+function readStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+export const customersHandlers = {
+    async list_customers(input, context) {
+        const payload = await requestShopifyGraphQL(context, context.fetcher, {
+            query: listCustomersQuery,
+            variables: connectionVariables(input),
+        });
+        const customers = requiredResponseRecord(requiredResponseRecord(payload.data, "data").customers, "customers");
+        return {
+            customers: readEdges(customers).map((edge) => normalizeCustomer(edge)),
+            pageInfo: normalizePageInfo(requiredResponseRecord(customers.pageInfo, "pageInfo")),
+        };
+    },
+    async get_customer(input, context) {
+        const payload = await requestShopifyGraphQL(context, context.fetcher, {
+            query: getCustomerQuery,
+            variables: {
+                id: input.id,
+            },
+        });
+        const customer = readNullableObject(requiredResponseRecord(payload.data, "data").customer, "customer");
+        return { customer: customer ? normalizeCustomerDetail(customer) : null };
+    },
+};

package/src/providers/shopify/executors.d.ts

@@ -1,7 +1,9 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { ProviderOAuthRuntime } from "../../oauth/oauth-token.ts";
 import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 import type { PollDefinition } from "../../triggers/common/poll.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const oauth: ProviderOAuthRuntime;
 export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/shopify/executors.js

@@ -1,12 +1,32 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { defineProviderExecutors, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
-import { buildShopifyRestApiBaseUrl, normalizeShopDomain, shopifyActionHandlers, validateShopifyCredential, } from "./runtime.js";
-import { shopifyReadContentScope } from "./scopes.js";
+import { defineProviderExecutors, defineProviderProxy, ProviderRequestError, requiredResponseRecord, } from "../provider-runtime.js";
+import { bulkHandlers } from "./bulk.js";
+import { catalogHandlers } from "./catalog.js";
+import { buildShopifyApiBaseUrl, requestShopifyGraphQL } from "./client.js";
+import { contentActionHandlers } from "./content-runtime.js";
+import { customersHandlers } from "./customers.js";
+import { graphqlHandlers } from "./graphql.js";
+import { inventoryHandlers } from "./inventory.js";
+import { shopifyOAuth } from "./oauth.js";
+import { operationHandlers } from "./operations.js";
+import { ordersHandlers } from "./orders.js";
+import { normalizeShopDomain } from "./shop-domain.js";
+import { shopHandlers } from "./shop.js";
 import { shopifyShopEvent } from "./trigger-on-shop-event.js";
 const service = "shopify";
 export const executors = defineProviderExecutors({
     service,
-    handlers: shopifyActionHandlers,
+    handlers: {
+        ...operationHandlers,
+        ...shopHandlers,
+        ...catalogHandlers,
+        ...ordersHandlers,
+        ...customersHandlers,
+        ...inventoryHandlers,
+        ...bulkHandlers,
+        ...graphqlHandlers,
+        ...contentActionHandlers,
+    },
     async createContext(context, fetcher) {
         const credential = await requireShopifyCredential(context);
         return {
@@ -14,22 +34,25 @@ export const executors = defineProviderExecutors({
             shopDomain: shopifyCredentialDomain(credential),
             fetcher,
             signal: context.signal,
+            transitFiles: context.transitFiles,
         };
     },
 });
 export const proxy = defineProviderProxy({
     service,
     baseUrl: async (context) => {
-        return buildShopifyRestApiBaseUrl(shopifyCredentialDomain(await requireShopifyCredential(context)));
+        return buildShopifyApiBaseUrl(shopifyCredentialDomain(await requireShopifyCredential(context)));
     },
     auth: { type: "none" },
     async customizeRequest({ context, headers }) {
+        headers.set("accept", "application/json");
+        headers.set("content-type", "application/json");
         headers.set("x-shopify-access-token", shopifyAccessToken(await requireShopifyCredential(context)));
     },
 });
 export const credentialValidators = {
     apiKey(input, { fetcher, signal }) {
-        return validateShopifyCredential(input.apiKey, normalizeShopDomain(optionalString(input.values.shopDomain)), [shopifyReadContentScope], fetcher, signal);
+        return validateShopifyCredential(input.apiKey, normalizeShopDomain(optionalString(input.values.shopDomain)), [], fetcher, signal);
     },
     oauth2(input, { fetcher, signal }) {
         return validateShopifyCredential(input.accessToken, shopifyCredentialDomain(input), parseShopifyScopes(input.metadata.scope), fetcher, signal);
@@ -61,6 +84,24 @@ function parseShopifyScopes(value) {
     return (optionalString(value) ?? "")
         .split(/[ ,]+/u)
         .map((scope) => scope.trim())
-        .filter(Boolean);
+        .filter(Boolean)
+        .flatMap((scope) => (scope.startsWith("write_") ? [scope, `read_${scope.slice(6)}`] : [scope]));
 }
+export const oauth = shopifyOAuth;
 export const triggers = [shopifyShopEvent];
+async function validateShopifyCredential(accessToken, shopDomain, grantedScopes, fetcher, signal) {
+    const payload = await requestShopifyGraphQL({ accessToken, shopDomain, signal }, fetcher, {
+        query: "query ShopifyAccount { shop { id name myshopifyDomain } }",
+    });
+    const shop = requiredResponseRecord(requiredResponseRecord(payload.data, "data").shop, "shop");
+    return {
+        profile: { accountId: `shopify:${shopDomain}`, displayName: optionalString(shop.name) ?? shopDomain },
+        grantedScopes,
+        metadata: {
+            shopDomain,
+            apiBaseUrl: buildShopifyApiBaseUrl(shopDomain),
+            shopId: shop.id,
+            myshopifyDomain: shop.myshopifyDomain,
+        },
+    };
+}

package/src/providers/shopify/graphql.d.ts

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

package/src/providers/shopify/graphql.js

@@ -0,0 +1,17 @@
+import { optionalRecord } from "../../core/cast.js";
+import { requiredResponseRecord } from "../provider-runtime.js";
+import { requestShopifyGraphQL } from "./client.js";
+export const graphqlHandlers = {
+    async execute_graphql(input, context) {
+        const payload = await requestShopifyGraphQL(context, context.fetcher, {
+            query: String(input.query),
+            variables: optionalRecord(input.variables),
+        });
+        const data = requiredResponseRecord(payload.data, "data");
+        const extensions = optionalRecord(payload.extensions);
+        return {
+            data,
+            extensions: extensions ? extensions : undefined,
+        };
+    },
+};

package/src/providers/shopify/inventory.d.ts

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