@catandbox/schrodinger-shopify-adapter 0.1.0

package/dist/server/routes.js

@@ -0,0 +1,353 @@
+import { signSchrodingerRequest } from "./signing";
+import { ShopifyAuthError, createPrincipalContext, verifyShopifyWebhookHmac } from "./shopifyAuth";
+const DEFAULT_BASE_PATH = "/support/api";
+const DEFAULT_PREFILL_CAPS = {
+    title: 120,
+    category: 80,
+    description: 10_000
+};
+export function createShopifyProxyHandler(options) {
+    const basePath = normalizePathPrefix(options.basePath ?? DEFAULT_BASE_PATH);
+    return async (request) => {
+        const requestId = request.headers.get("X-Request-Id") ?? options.requestIdFactory?.() ?? crypto.randomUUID();
+        const fetchImpl = options.fetchImpl ?? fetch;
+        try {
+            const url = new URL(request.url);
+            const relativePath = toRelativePath(url.pathname, basePath);
+            if (relativePath === null) {
+                return jsonError(404, "NOT_FOUND", "Route not found", requestId);
+            }
+            const principal = await createPrincipalContext(request, {
+                shopifyApiKey: options.shopifyApiKey,
+                shopifyApiSecret: options.shopifyApiSecret
+            });
+            const resolution = await resolveProxyRequest(request, relativePath, url.searchParams, principal);
+            const upstreamUrl = new URL(`${trimTrailingSlash(options.schApiBaseUrl)}${resolution.upstreamPath}`);
+            resolution.query.forEach((value, key) => {
+                upstreamUrl.searchParams.set(key, value);
+            });
+            const signed = await signSchrodingerRequest({
+                env: {
+                    schAppId: options.schAppId,
+                    schKeyId: options.schKeyId,
+                    schSecret: options.schSecret
+                },
+                method: request.method,
+                path: resolution.upstreamPath,
+                query: upstreamUrl.searchParams,
+                body: resolution.body
+            });
+            const upstreamHeaders = new Headers(signed.headers);
+            upstreamHeaders.set("X-Request-Id", requestId);
+            upstreamHeaders.set(options.principalContextHeaderName ?? "X-Sch-Principal-Context", JSON.stringify({
+                shopDomain: principal.shopDomain,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId,
+                displayName: principal.displayName,
+                email: principal.email
+            }));
+            if (signed.rawBody) {
+                upstreamHeaders.set("content-type", "application/json");
+            }
+            const upstreamResponse = await fetchImpl(upstreamUrl, {
+                method: request.method,
+                headers: upstreamHeaders,
+                body: signed.rawBody || null
+            });
+            return await copyResponse(upstreamResponse, requestId);
+        }
+        catch (error) {
+            if (error instanceof ShopifyAuthError) {
+                return jsonError(error.status, error.code, error.message, requestId);
+            }
+            if (error instanceof ProxyRouteError) {
+                return jsonError(error.status, error.code, error.message, requestId);
+            }
+            return jsonError(500, "INTERNAL_ERROR", "Unexpected proxy error", requestId);
+        }
+    };
+}
+export function parsePrefillRoute(input, options) {
+    const url = typeof input === "string" ? new URL(input, "https://local.invalid") : input;
+    const caps = { ...DEFAULT_PREFILL_CAPS, ...(options.caps ?? {}) };
+    const errors = {};
+    const title = (url.searchParams.get("title") ?? "").trim();
+    const categoryRaw = (url.searchParams.get("category") ?? "").trim();
+    const description = (url.searchParams.get("description") ?? "").trim();
+    const boundedTitle = enforceLength("title", title, caps.title, errors);
+    const boundedCategory = enforceLength("category", categoryRaw, caps.category, errors);
+    const boundedDescription = enforceLength("description", description, caps.description, errors);
+    const categoryId = boundedCategory
+        ? options.categories.some((category) => category.id === boundedCategory)
+            ? boundedCategory
+            : null
+        : null;
+    if (boundedCategory && !categoryId) {
+        errors.category = "Prefill category is not available for this integration";
+    }
+    return {
+        title: boundedTitle,
+        categoryId,
+        description: boundedDescription,
+        errors,
+        isValid: Object.keys(errors).length === 0
+    };
+}
+export function createShopifyWebhookHandlers(options) {
+    return {
+        handleCustomersDataRequestWebhook: (request) => forwardWebhook(request, "customers/data_request", "/admin/gdpr/data-request", options),
+        handleCustomersRedactWebhook: (request) => forwardWebhook(request, "customers/redact", "/admin/gdpr/customer-redact", options),
+        handleShopRedactWebhook: (request) => forwardWebhook(request, "shop/redact", "/admin/gdpr/shop-redact", options),
+        handleAppUninstalledWebhook: (request) => forwardWebhook(request, "app/uninstalled", "/admin/gdpr/shop-redact", options, true)
+    };
+}
+export async function handleCustomersDataRequestWebhook(request, options) {
+    return forwardWebhook(request, "customers/data_request", "/admin/gdpr/data-request", options);
+}
+export async function handleCustomersRedactWebhook(request, options) {
+    return forwardWebhook(request, "customers/redact", "/admin/gdpr/customer-redact", options);
+}
+export async function handleShopRedactWebhook(request, options) {
+    return forwardWebhook(request, "shop/redact", "/admin/gdpr/shop-redact", options);
+}
+export async function handleAppUninstalledWebhook(request, options) {
+    return forwardWebhook(request, "app/uninstalled", "/admin/gdpr/shop-redact", options, true);
+}
+async function resolveProxyRequest(request, relativePath, requestQuery, principal) {
+    if (request.method === "GET" && relativePath === "/categories") {
+        return {
+            upstreamPath: "/v1/categories",
+            query: new URLSearchParams(requestQuery),
+            body: undefined
+        };
+    }
+    if (request.method === "GET" && relativePath === "/portal-config") {
+        return {
+            upstreamPath: "/v1/portal-config",
+            query: new URLSearchParams(requestQuery),
+            body: undefined
+        };
+    }
+    if (request.method === "GET" && relativePath === "/tickets") {
+        const query = new URLSearchParams(requestQuery);
+        query.set("tenantExternalId", principal.tenantExternalId);
+        return {
+            upstreamPath: "/v1/tickets",
+            query,
+            body: undefined
+        };
+    }
+    const ticketMatch = relativePath.match(/^\/tickets\/([^/]+)$/);
+    if (request.method === "GET" && ticketMatch) {
+        const query = new URLSearchParams(requestQuery);
+        query.set("tenantExternalId", principal.tenantExternalId);
+        return {
+            upstreamPath: `/v1/tickets/${encodeURIComponent(decodeURIComponent(ticketMatch[1] ?? ""))}`,
+            query,
+            body: undefined
+        };
+    }
+    if (request.method === "POST" && relativePath === "/tickets") {
+        const payload = await parseOptionalJsonBody(request);
+        return {
+            upstreamPath: "/v1/tickets",
+            query: new URLSearchParams(requestQuery),
+            body: {
+                ...payload,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId
+            }
+        };
+    }
+    const messageMatch = relativePath.match(/^\/tickets\/([^/]+)\/messages$/);
+    if (request.method === "POST" && messageMatch) {
+        const payload = await parseOptionalJsonBody(request);
+        return {
+            upstreamPath: `/v1/tickets/${encodeURIComponent(decodeURIComponent(messageMatch[1] ?? ""))}/messages`,
+            query: new URLSearchParams(requestQuery),
+            body: {
+                ...payload,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId
+            }
+        };
+    }
+    const actionMatch = relativePath.match(/^\/tickets\/([^/]+)\/(close|archive|reopen)$/);
+    if (request.method === "POST" && actionMatch) {
+        return {
+            upstreamPath: `/v1/tickets/${encodeURIComponent(decodeURIComponent(actionMatch[1] ?? ""))}/${actionMatch[2]}`,
+            query: new URLSearchParams(requestQuery),
+            body: {
+                tenantExternalId: principal.tenantExternalId
+            }
+        };
+    }
+    const ticketRatingMatch = relativePath.match(/^\/tickets\/([^/]+)\/ratings$/);
+    if (request.method === "POST" && ticketRatingMatch) {
+        const payload = await parseOptionalJsonBody(request);
+        return {
+            upstreamPath: `/v1/tickets/${encodeURIComponent(decodeURIComponent(ticketRatingMatch[1] ?? ""))}/ratings`,
+            query: new URLSearchParams(requestQuery),
+            body: {
+                ...payload,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId
+            }
+        };
+    }
+    const messageRatingMatch = relativePath.match(/^\/messages\/([^/]+)\/ratings$/);
+    if (request.method === "POST" && messageRatingMatch) {
+        const payload = await parseOptionalJsonBody(request);
+        return {
+            upstreamPath: `/v1/messages/${encodeURIComponent(decodeURIComponent(messageRatingMatch[1] ?? ""))}/ratings`,
+            query: new URLSearchParams(requestQuery),
+            body: {
+                ...payload,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId
+            }
+        };
+    }
+    if (request.method === "POST" && relativePath === "/uploads/init") {
+        const payload = await parseOptionalJsonBody(request);
+        return {
+            upstreamPath: "/v1/uploads/init",
+            query: new URLSearchParams(requestQuery),
+            body: {
+                ...payload,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId
+            }
+        };
+    }
+    if (request.method === "POST" && relativePath === "/uploads/complete") {
+        const payload = await parseOptionalJsonBody(request);
+        return {
+            upstreamPath: "/v1/uploads/complete",
+            query: new URLSearchParams(requestQuery),
+            body: {
+                ...payload,
+                tenantExternalId: principal.tenantExternalId,
+                principalExternalId: principal.principalExternalId
+            }
+        };
+    }
+    throw new ProxyRouteError("NOT_FOUND", "Adapter route not found", 404);
+}
+async function forwardWebhook(request, topic, adminPath, options, disablePortalAccess = false) {
+    const requestId = request.headers.get("X-Request-Id") ?? options.requestIdFactory?.() ?? crypto.randomUUID();
+    const rawBody = await request.clone().text();
+    const hmacHeader = request.headers.get("X-Shopify-Hmac-Sha256") ?? request.headers.get("x-shopify-hmac-sha256");
+    const validHmac = await verifyShopifyWebhookHmac({
+        rawBody,
+        hmacHeader,
+        shopifyApiSecret: options.shopifyApiSecret
+    });
+    if (!validHmac) {
+        return jsonError(401, "INVALID_WEBHOOK_SIGNATURE", "Shopify webhook HMAC validation failed", requestId);
+    }
+    if (!options.schAdminApiToken) {
+        return jsonError(500, "MISSING_SCH_ADMIN_API_TOKEN", "schAdminApiToken is required for GDPR webhook forwarding", requestId);
+    }
+    const payload = parseWebhookPayload(rawBody, requestId);
+    if (payload instanceof Response) {
+        return payload;
+    }
+    if (disablePortalAccess) {
+        const shopDomain = inferWebhookShopDomain(payload);
+        if (!shopDomain) {
+            return jsonError(422, "INVALID_WEBHOOK_PAYLOAD", "Missing shop domain in uninstall webhook", requestId);
+        }
+        await options.disablePortalAccess?.({ shopDomain, payload, topic });
+    }
+    const url = new URL(`${trimTrailingSlash(options.schApiBaseUrl)}${adminPath}`);
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const upstream = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${options.schAdminApiToken}`,
+            "content-type": "application/json",
+            "X-Request-Id": requestId
+        },
+        body: rawBody
+    });
+    return await copyResponse(upstream, requestId);
+}
+async function parseOptionalJsonBody(request) {
+    const raw = await request.clone().text();
+    if (!raw.trim()) {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new ProxyRouteError("INVALID_JSON", "Request body must be valid JSON", 400);
+    }
+}
+function parseWebhookPayload(rawBody, requestId) {
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch {
+        return jsonError(400, "INVALID_JSON", "Webhook payload must be valid JSON", requestId);
+    }
+}
+function inferWebhookShopDomain(payload) {
+    const candidate = payload.shop_domain ?? payload.myshopify_domain ?? payload.shopDomain;
+    return typeof candidate === "string" && candidate.trim() ? candidate.trim().toLowerCase() : null;
+}
+function normalizePathPrefix(path) {
+    const withSlash = path.startsWith("/") ? path : `/${path}`;
+    return withSlash.replace(/\/+$/, "");
+}
+function toRelativePath(pathname, basePath) {
+    if (pathname === basePath) {
+        return "/";
+    }
+    if (pathname.startsWith(`${basePath}/`)) {
+        return pathname.slice(basePath.length);
+    }
+    return null;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+async function copyResponse(response, requestId) {
+    const headers = new Headers(response.headers);
+    if (!headers.get("X-Request-Id")) {
+        headers.set("X-Request-Id", requestId);
+    }
+    const body = await response.arrayBuffer();
+    return new Response(body, { status: response.status, statusText: response.statusText, headers });
+}
+function jsonError(status, code, message, requestId) {
+    return new Response(JSON.stringify({
+        error: code,
+        message,
+        requestId
+    }), {
+        status,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+            "X-Request-Id": requestId
+        }
+    });
+}
+function enforceLength(field, value, maxLength, errors) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    errors[field] = `${field} exceeds ${maxLength} characters`;
+    return value.slice(0, maxLength);
+}
+class ProxyRouteError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.name = "ProxyRouteError";
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/server/shopifyAuth.d.ts

@@ -0,0 +1,28 @@
+import type { PrincipalContext, ShopifySessionVerificationOptions } from "./types";
+interface ShopifySessionClaims {
+    aud?: string | string[];
+    dest?: string;
+    email?: string;
+    exp?: number;
+    iat?: number;
+    iss?: string;
+    nbf?: number;
+    sub?: string;
+    user_email?: string;
+    user_name?: string;
+    [key: string]: unknown;
+}
+export declare class ShopifyAuthError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status?: number);
+}
+export declare function extractShopifySessionToken(request: Request): string | null;
+export declare function createPrincipalContext(request: Request, options: ShopifySessionVerificationOptions): Promise<PrincipalContext>;
+export declare function verifyShopifySessionToken(token: string, options: ShopifySessionVerificationOptions): Promise<ShopifySessionClaims>;
+export declare function verifyShopifyWebhookHmac(input: {
+    rawBody: string;
+    hmacHeader: string | null;
+    shopifyApiSecret: string;
+}): Promise<boolean>;
+export {};

package/dist/server/shopifyAuth.js

@@ -0,0 +1,179 @@
+export class ShopifyAuthError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 401) {
+        super(message);
+        this.name = "ShopifyAuthError";
+        this.code = code;
+        this.status = status;
+    }
+}
+export function extractShopifySessionToken(request) {
+    const authHeader = request.headers.get("Authorization");
+    if (authHeader?.startsWith("Bearer ")) {
+        return authHeader.slice("Bearer ".length).trim();
+    }
+    const fallbackHeader = request.headers.get("X-Shopify-Session-Token") ??
+        request.headers.get("x-shopify-session-token");
+    return fallbackHeader?.trim() || null;
+}
+export async function createPrincipalContext(request, options) {
+    const token = extractShopifySessionToken(request);
+    if (!token) {
+        throw new ShopifyAuthError("MISSING_SHOPIFY_SESSION_TOKEN", "Missing Shopify session token");
+    }
+    const payload = await verifyShopifySessionToken(token, options);
+    const shopDomain = inferShopDomain(payload);
+    const principalExternalId = inferPrincipalExternalId(payload);
+    const displayName = asOptionalString(payload.user_name) ?? null;
+    const email = asOptionalString(payload.user_email) ?? asOptionalString(payload.email) ?? null;
+    return {
+        tenantExternalId: shopDomain,
+        principalExternalId,
+        displayName,
+        email,
+        shopDomain,
+        tokenPayload: payload
+    };
+}
+export async function verifyShopifySessionToken(token, options) {
+    const [headerPart, payloadPart, signaturePart] = token.split(".");
+    if (!headerPart || !payloadPart || !signaturePart) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Invalid JWT format");
+    }
+    const headerJson = decodeBase64UrlToText(headerPart);
+    const header = parseJson(headerJson, "Invalid JWT header");
+    if (header.alg !== "HS256") {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Unsupported JWT alg");
+    }
+    const expectedSignature = await hmacSha256Base64Url(options.shopifyApiSecret, `${headerPart}.${payloadPart}`);
+    if (!timingSafeEqual(expectedSignature, signaturePart)) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "JWT signature mismatch");
+    }
+    const payloadJson = decodeBase64UrlToText(payloadPart);
+    const payload = parseJson(payloadJson, "Invalid JWT payload");
+    validateTemporalClaims(payload, options);
+    validateAudience(payload, options.shopifyApiKey);
+    return payload;
+}
+export async function verifyShopifyWebhookHmac(input) {
+    if (!input.hmacHeader) {
+        return false;
+    }
+    const expected = await hmacSha256Base64(input.shopifyApiSecret, input.rawBody);
+    return timingSafeEqual(expected, input.hmacHeader.trim());
+}
+function validateTemporalClaims(payload, options) {
+    const now = options.now ? options.now() : Math.floor(Date.now() / 1000);
+    const skew = options.clockSkewSeconds ?? 10;
+    if (typeof payload.exp !== "number") {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Missing exp claim");
+    }
+    if (payload.exp + skew < now) {
+        throw new ShopifyAuthError("EXPIRED_SHOPIFY_SESSION_TOKEN", "Shopify session token is expired");
+    }
+    if (typeof payload.nbf === "number" && payload.nbf - skew > now) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Shopify session token is not active yet");
+    }
+    if (typeof payload.iat === "number" && payload.iat - skew > now) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Shopify session token iat is in the future");
+    }
+}
+function validateAudience(payload, apiKey) {
+    const aud = payload.aud;
+    if (!aud) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Missing aud claim");
+    }
+    if (typeof aud === "string") {
+        if (aud !== apiKey) {
+            throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Shopify session token audience mismatch");
+        }
+        return;
+    }
+    if (Array.isArray(aud) && aud.includes(apiKey)) {
+        return;
+    }
+    throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Shopify session token audience mismatch");
+}
+function inferShopDomain(payload) {
+    const destination = asOptionalString(payload.dest);
+    if (destination) {
+        try {
+            const url = new URL(destination);
+            return normalizeShopDomain(url.hostname);
+        }
+        catch {
+            return normalizeShopDomain(destination);
+        }
+    }
+    const issuer = asOptionalString(payload.iss);
+    if (issuer) {
+        try {
+            const url = new URL(issuer);
+            return normalizeShopDomain(url.hostname);
+        }
+        catch {
+            // continue
+        }
+    }
+    throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Unable to infer Shopify shop domain");
+}
+function inferPrincipalExternalId(payload) {
+    const candidate = asOptionalString(payload.sub) ??
+        asOptionalString(payload.user_email) ??
+        asOptionalString(payload.email);
+    if (!candidate) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Unable to infer principal identifier from Shopify session token");
+    }
+    return candidate;
+}
+function normalizeShopDomain(domainLike) {
+    const normalized = domainLike
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/\/.*$/, "");
+    if (!normalized || !normalized.includes(".")) {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", "Invalid Shopify shop domain in token");
+    }
+    return normalized;
+}
+function parseJson(value, message) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new ShopifyAuthError("INVALID_SHOPIFY_SESSION_TOKEN", message, 401);
+    }
+}
+function decodeBase64UrlToText(input) {
+    const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = `${normalized}${"=".repeat((4 - (normalized.length % 4)) % 4)}`;
+    return atob(padded);
+}
+async function hmacSha256Base64Url(secret, value) {
+    const base64 = await hmacSha256Base64(secret, value);
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function hmacSha256Base64(secret, value) {
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(value));
+    let binary = "";
+    for (const byte of new Uint8Array(signature)) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+function timingSafeEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    let mismatch = 0;
+    for (let index = 0; index < left.length; index += 1) {
+        mismatch |= left.charCodeAt(index) ^ right.charCodeAt(index);
+    }
+    return mismatch === 0;
+}
+function asOptionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/dist/server/signing.d.ts

@@ -0,0 +1,18 @@
+import { type SignedHeaders } from "../signer";
+import type { AdapterEnvironment } from "./types";
+interface SignSchrodingerRequestInput {
+    env: Pick<AdapterEnvironment, "schAppId" | "schKeyId" | "schSecret">;
+    method: string;
+    path: string;
+    query?: URLSearchParams | string;
+    body?: unknown;
+    timestamp?: number;
+    nonce?: string;
+}
+interface SignedSchrodingerRequest {
+    headers: SignedHeaders;
+    rawBody: string;
+    queryString: string;
+}
+export declare function signSchrodingerRequest(input: SignSchrodingerRequestInput): Promise<SignedSchrodingerRequest>;
+export {};

package/dist/server/signing.js

@@ -0,0 +1,25 @@
+import { signRequest } from "../signer";
+export async function signSchrodingerRequest(input) {
+    const queryString = typeof input.query === "string" ? input.query : input.query ? input.query.toString() : "";
+    const rawBody = input.body === undefined
+        ? ""
+        : typeof input.body === "string"
+            ? input.body
+            : JSON.stringify(input.body);
+    const headers = await signRequest({
+        appId: input.env.schAppId,
+        keyId: input.env.schKeyId,
+        keySecret: input.env.schSecret,
+        timestamp: input.timestamp ?? Math.floor(Date.now() / 1000),
+        nonce: input.nonce ?? crypto.randomUUID(),
+        method: input.method,
+        path: input.path,
+        queryString,
+        rawBody
+    });
+    return {
+        headers,
+        rawBody,
+        queryString
+    };
+}

package/dist/server/types.d.ts

@@ -0,0 +1,60 @@
+export interface ShopifySessionVerificationOptions {
+    shopifyApiKey: string;
+    shopifyApiSecret: string;
+    clockSkewSeconds?: number;
+    now?: () => number;
+}
+export interface PrincipalContext {
+    tenantExternalId: string;
+    principalExternalId: string;
+    displayName: string | null;
+    email: string | null;
+    shopDomain: string;
+    tokenPayload: Record<string, unknown>;
+}
+export interface AdapterEnvironment {
+    schApiBaseUrl: string;
+    schAppId: string;
+    schKeyId: string;
+    schSecret: string;
+    shopifyApiKey: string;
+    shopifyApiSecret: string;
+    schAdminApiToken?: string;
+}
+export interface ProxyHandlerOptions extends AdapterEnvironment {
+    basePath?: string;
+    fetchImpl?: typeof fetch;
+    requestIdFactory?: () => string;
+    principalContextHeaderName?: string;
+}
+export interface PrefillLengthCaps {
+    title: number;
+    category: number;
+    description: number;
+}
+export interface PrefillState {
+    title: string;
+    categoryId: string | null;
+    description: string;
+    errors: {
+        title?: string;
+        category?: string;
+        description?: string;
+    };
+    isValid: boolean;
+}
+export interface PrefillParseOptions {
+    categories: Array<{
+        id: string;
+    }>;
+    caps?: Partial<PrefillLengthCaps>;
+}
+export interface WebhookForwardingOptions extends AdapterEnvironment {
+    fetchImpl?: typeof fetch;
+    requestIdFactory?: () => string;
+    disablePortalAccess?: (input: {
+        shopDomain: string;
+        payload: unknown;
+        topic: string;
+    }) => Promise<void> | void;
+}

package/dist/server/types.js

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