@keystrokehq/shopify 0.0.1

package/dist/integration-BN3pjCz4.mjs

@@ -0,0 +1,204 @@
+import { defineOfficialIntegration } from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import { CredentialSet } from "@keystrokehq/core";
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { TokenExchangeError, normalizeOAuthTokens, parseOAuthTokenResponse } from "@keystrokehq/credential-connection";
+
+//#region src/_official/provider-app.ts
+const shopifyAppCredentialSet = new CredentialSet({
+	id: "shopify-app",
+	exposure: "platform-only",
+	name: "Shopify App",
+	auth: z.object({
+		clientId: z.string(),
+		clientSecret: z.string(),
+		webhookSecret: z.string()
+	})
+});
+const shopifyPlatformProviderSeed = {
+	provider: "shopify",
+	appRef: "shopify-platform",
+	displayName: "Shopify Platform",
+	credentialSetName: "Keystroke Shopify Platform App",
+	envShape: {
+		KEYSTROKE_PLATFORM_SHOPIFY_APP_ID: z.string().optional(),
+		KEYSTROKE_PLATFORM_SHOPIFY_CLIENT_ID: z.string().optional(),
+		KEYSTROKE_PLATFORM_SHOPIFY_CLIENT_SECRET: z.string().optional(),
+		KEYSTROKE_PLATFORM_SHOPIFY_WEBHOOK_SECRET: z.string().optional()
+	},
+	requiredEnvKeys: [
+		"KEYSTROKE_PLATFORM_SHOPIFY_APP_ID",
+		"KEYSTROKE_PLATFORM_SHOPIFY_CLIENT_ID",
+		"KEYSTROKE_PLATFORM_SHOPIFY_CLIENT_SECRET",
+		"KEYSTROKE_PLATFORM_SHOPIFY_WEBHOOK_SECRET"
+	],
+	externalAppIdEnvKey: "KEYSTROKE_PLATFORM_SHOPIFY_APP_ID",
+	buildCredentials: (env) => ({
+		clientId: env.KEYSTROKE_PLATFORM_SHOPIFY_CLIENT_ID,
+		clientSecret: env.KEYSTROKE_PLATFORM_SHOPIFY_CLIENT_SECRET,
+		webhookSecret: env.KEYSTROKE_PLATFORM_SHOPIFY_WEBHOOK_SECRET
+	})
+};
+
+//#endregion
+//#region src/oauth-connection.ts
+/**
+* Shopify OAuth connection configuration.
+*
+* Shopify's OAuth flow is per-shop: every handshake is scoped to a specific
+* `{shop}.myshopify.com` domain that the user supplies up front. That shop
+* domain shows up in three places that make Shopify different from a plain
+* OAuth 2.0 integration:
+*
+*  - `buildAuthUrl` must point at the shop-specific authorize endpoint at
+*    `https://{shop}.myshopify.com/admin/oauth/authorize`. The shop domain is
+*    threaded in from the initiate-connection request via `initiateInput`.
+*  - `exchangeCode` verifies the Shopify HMAC signature on the callback query
+*    string before trusting any of it, and POSTs to the same shop-specific
+*    token endpoint. HMAC verification uses `timingSafeEqual` to avoid leaking
+*    bytes through timing side channels.
+*  - `refreshToken` reads the shop domain out of `oauthClient.metadata` (set
+*    during the initial exchange) so proactive refreshes still target the
+*    right store, and the `vault` mapping promotes the shop domain into
+*    `SHOPIFY_STORE_DOMAIN` so the vault has both the access token and the
+*    store it belongs to.
+*
+* Shopify responds with JSON, so we reuse `parseOAuthTokenResponse` +
+* `normalizeOAuthTokens` from `@keystrokehq/credential-connection` to avoid reimplementing
+* the token-response plumbing.
+*/
+function normalizeShopifyShopDomain(raw) {
+	const trimmed = raw?.trim().toLowerCase();
+	if (!trimmed) throw new Error("Shopify requires a store domain.");
+	const normalized = trimmed.endsWith(".myshopify.com") ? trimmed : `${trimmed}.myshopify.com`;
+	if (!/^[a-z0-9][a-z0-9-]*\.myshopify\.com$/i.test(normalized)) throw new Error("Invalid Shopify store domain.");
+	return normalized;
+}
+function verifyShopifyCallbackHmac(queryParams, clientSecret) {
+	const receivedHmac = queryParams.hmac;
+	if (!receivedHmac) return false;
+	const canonical = Object.entries(queryParams).filter(([key]) => key !== "hmac" && key !== "signature").sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join("&");
+	const expected = createHmac("sha256", clientSecret).update(canonical).digest("hex");
+	const received = Buffer.from(receivedHmac, "utf8");
+	const expectedBuffer = Buffer.from(expected, "utf8");
+	if (received.length !== expectedBuffer.length) return false;
+	return timingSafeEqual(received, expectedBuffer);
+}
+function resolveShopifyTokenUrl(shopDomain) {
+	return `https://${shopDomain}/admin/oauth/access_token`;
+}
+async function shopifyTokenPost(shopDomain, body, missingTokenError) {
+	const response = await fetch(resolveShopifyTokenUrl(shopDomain), {
+		method: "POST",
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(body)
+	});
+	if (!response.ok) throw new TokenExchangeError(response.status);
+	const raw = await parseOAuthTokenResponse(response);
+	raw._shopifyShopDomain = shopDomain;
+	const { accessToken, refreshToken, expiresIn } = normalizeOAuthTokens(raw);
+	if (!accessToken) throw new Error(missingTokenError);
+	return {
+		accessToken,
+		refreshToken,
+		expiresIn,
+		raw
+	};
+}
+const shopifyOAuthConnection = {
+	kind: "oauth",
+	tokenType: "refreshable",
+	authUrl: "https://{shop}.myshopify.com/admin/oauth/authorize",
+	tokenUrl: "https://{shop}.myshopify.com/admin/oauth/access_token",
+	revokeUrl: null,
+	scopes: [
+		"read_products",
+		"write_products",
+		"read_orders",
+		"write_orders",
+		"read_customers",
+		"write_customers",
+		"read_inventory",
+		"write_inventory",
+		"read_locations",
+		"read_fulfillments",
+		"write_fulfillments",
+		"read_content",
+		"write_content",
+		"read_webhooks",
+		"write_webhooks"
+	],
+	vault: {
+		accessToken: "SHOPIFY_ACCESS_TOKEN",
+		raw: { SHOPIFY_STORE_DOMAIN: "_shopifyShopDomain" }
+	},
+	buildAuthUrl({ oauthClient, redirectUri, state, connection, initiateInput, requestedScopes }) {
+		const rawShopDomain = initiateInput?.shopDomain;
+		if (typeof rawShopDomain !== "string") throw new Error("Shopify requires a store domain.");
+		const scopes = requestedScopes ?? connection.scopes;
+		const shopDomain = normalizeShopifyShopDomain(rawShopDomain);
+		const url = new URL(`https://${shopDomain}/admin/oauth/authorize`);
+		url.searchParams.set("client_id", oauthClient.clientId);
+		url.searchParams.set("scope", scopes.join(","));
+		url.searchParams.set("redirect_uri", redirectUri);
+		url.searchParams.set("state", state);
+		return url.toString();
+	},
+	async exchangeCode({ oauthClient, code, queryParams }) {
+		if (!code) throw new Error("Missing authorization code");
+		const shopDomain = normalizeShopifyShopDomain(queryParams.shop);
+		if (!verifyShopifyCallbackHmac(queryParams, oauthClient.clientSecret)) throw new Error("Invalid Shopify OAuth callback signature");
+		return shopifyTokenPost(shopDomain, {
+			client_id: oauthClient.clientId,
+			client_secret: oauthClient.clientSecret,
+			code
+		}, "No access token in Shopify response");
+	},
+	async refreshToken({ oauthClient, refreshToken }) {
+		const rawShopDomain = oauthClient.metadata?.shopDomain;
+		if (typeof rawShopDomain !== "string") throw new Error("Missing Shopify store domain for token refresh.");
+		return shopifyTokenPost(normalizeShopifyShopDomain(rawShopDomain), {
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: oauthClient.clientId,
+			client_secret: oauthClient.clientSecret
+		}, "No access token in Shopify refresh response");
+	},
+	extractInstallationInfo({ tokenResult }) {
+		const shopDomain = typeof tokenResult.raw._shopifyShopDomain === "string" ? tokenResult.raw._shopifyShopDomain : void 0;
+		return {
+			externalInstallationId: shopDomain,
+			externalWorkspaceId: shopDomain,
+			metadata: shopDomain ? { shopDomain } : void 0
+		};
+	}
+};
+
+//#endregion
+//#region src/integration.ts
+const shopifyStoreDomainSchema = z.string().min(1).regex(/^[a-z0-9][a-z0-9-]*\.myshopify\.com$/i, "Shopify store domain must look like \"example.myshopify.com\".");
+const shopifyAuthSchema = z.object({
+	SHOPIFY_STORE_DOMAIN: shopifyStoreDomainSchema,
+	SHOPIFY_ACCESS_TOKEN: z.string().min(1)
+});
+const shopifyOfficialIntegration = {
+	id: "shopify",
+	name: "Shopify",
+	description: "Shopify Admin API — stores, products, orders, customers, and webhooks",
+	auth: shopifyAuthSchema,
+	connections: [{
+		id: "oauth",
+		...shopifyOAuthConnection
+	}]
+};
+const shopifyBundle = defineOfficialIntegration({
+	...shopifyOfficialIntegration,
+	internal: { providerApp: shopifyAppCredentialSet }
+});
+const shopify = shopifyBundle.credentialSet;
+
+//#endregion
+export { shopifyAppCredentialSet as a, shopifyStoreDomainSchema as i, shopifyBundle as n, shopifyPlatformProviderSeed as o, shopifyOfficialIntegration as r, shopify as t };

package/dist/integration-BwDBsGX-.d.mts

@@ -0,0 +1,71 @@
+import * as _keystrokehq_integration_authoring_official0 from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
+
+//#region src/integration.d.ts
+declare const shopifyOfficialIntegration: {
+  id: "shopify";
+  name: string;
+  description: string;
+  auth: z.ZodObject<{
+    SHOPIFY_STORE_DOMAIN: z.ZodString;
+    SHOPIFY_ACCESS_TOKEN: z.ZodString;
+  }, z.core.$strip>;
+  connections: {
+    kind: "oauth";
+    tokenType: "refreshable";
+    authUrl: "https://{shop}.myshopify.com/admin/oauth/authorize";
+    tokenUrl: "https://{shop}.myshopify.com/admin/oauth/access_token";
+    revokeUrl: null;
+    scopes: readonly ["read_products", "write_products", "read_orders", "write_orders", "read_customers", "write_customers", "read_inventory", "write_inventory", "read_locations", "read_fulfillments", "write_fulfillments", "read_content", "write_content", "read_webhooks", "write_webhooks"];
+    vault: {
+      readonly accessToken: "SHOPIFY_ACCESS_TOKEN";
+      readonly raw: {
+        readonly SHOPIFY_STORE_DOMAIN: "_shopifyShopDomain";
+      };
+    };
+    buildAuthUrl: ({
+      oauthClient,
+      redirectUri,
+      state,
+      connection,
+      initiateInput,
+      requestedScopes
+    }: _keystrokehq_core_credential_set0.BuildAuthUrlContext) => string;
+    exchangeCode: ({
+      oauthClient,
+      code,
+      queryParams
+    }: _keystrokehq_core_credential_set0.ExchangeCodeContext) => Promise<_keystrokehq_core_credential_set0.TokenResult>;
+    refreshToken: ({
+      oauthClient,
+      refreshToken
+    }: _keystrokehq_core_credential_set0.RefreshTokenContext) => Promise<_keystrokehq_core_credential_set0.TokenResult>;
+    extractInstallationInfo: ({
+      tokenResult
+    }: _keystrokehq_core_credential_set0.ExtractInstallationContext) => {
+      externalInstallationId: string | undefined;
+      externalWorkspaceId: string | undefined;
+      metadata: {
+        shopDomain: string;
+      } | undefined;
+    };
+    id: string;
+  }[];
+};
+declare const shopifyBundle: _keystrokehq_integration_authoring_official0.OfficialIntegrationBundle<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>;
+declare const shopify: _keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>;
+type ShopifyCredentials = InferCredentialSetAuth<typeof shopify>;
+//#endregion
+export { shopifyOfficialIntegration as i, shopify as n, shopifyBundle as r, ShopifyCredentials as t };

package/dist/inventory.d.mts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/inventory.d.ts
+declare const listInventoryItems: _keystrokehq_core0.Operation<z.ZodObject<{
+  first: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+  after: z.ZodOptional<z.ZodString>;
+  query: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sku: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tracked: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  pageInfo: z.ZodObject<{
+    hasNextPage: z.ZodBoolean;
+    hasPreviousPage: z.ZodOptional<z.ZodBoolean>;
+    startCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    endCursor: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getInventoryItem: _keystrokehq_core0.Operation<z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  sku: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  tracked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getInventoryLevelsForItem: _keystrokehq_core0.Operation<z.ZodObject<{
+  inventoryItemId: z.ZodString;
+  first: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+  after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    quantities: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+    item: z.ZodOptional<z.ZodObject<{
+      id: z.ZodString;
+      sku: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      tracked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    location: z.ZodOptional<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      isActive: z.ZodOptional<z.ZodBoolean>;
+      fulfillsOnlineOrders: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  pageInfo: z.ZodObject<{
+    hasNextPage: z.ZodBoolean;
+    hasPreviousPage: z.ZodOptional<z.ZodBoolean>;
+    startCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    endCursor: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const adjustInventoryQuantities: _keystrokehq_core0.Operation<z.ZodObject<{
+  name: z.ZodDefault<z.ZodString>;
+  reason: z.ZodString;
+  referenceDocumentUri: z.ZodOptional<z.ZodString>;
+  changes: z.ZodArray<z.ZodObject<{
+    inventoryItemId: z.ZodString;
+    locationId: z.ZodString;
+    delta: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  createdAt: z.ZodOptional<z.ZodISODateTime>;
+  reason: z.ZodString;
+  referenceDocumentUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  changes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    delta: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { adjustInventoryQuantities, getInventoryItem, getInventoryLevelsForItem, listInventoryItems };

package/dist/inventory.mjs

@@ -0,0 +1,182 @@
+import { shopifyConnectionNodesSchema, shopifyGlobalIdSchema, shopifyInventoryItemSchema, shopifyInventoryLevelSchema, shopifyUserErrorSchema } from "./schemas.mjs";
+import { createShopifyClient } from "./client.mjs";
+import { t as shopifyOperation } from "./factory-DC-gY8L0.mjs";
+import { r as shopifyPageInputSchema, t as assertNoUserErrors } from "./operation-helpers-CKEDIx0o.mjs";
+import { z } from "zod";
+
+//#region src/inventory.ts
+const inventoryItemSelection = `
+  id
+  sku
+  tracked
+`;
+const inventoryLevelSelection = `
+  id
+  quantities(names: ["available", "committed", "incoming", "on_hand", "reserved"]) {
+    name
+    quantity
+  }
+  item {
+    ${inventoryItemSelection}
+  }
+  location {
+    id
+    name
+    isActive
+    fulfillsOnlineOrders
+  }
+`;
+const listInventoryItemsResponseSchema = z.object({ inventoryItems: shopifyConnectionNodesSchema(shopifyInventoryItemSchema) });
+const getInventoryItemResponseSchema = z.object({ inventoryItem: shopifyInventoryItemSchema.nullable() });
+const inventoryLevelsResponseSchema = z.object({ inventoryItem: z.object({ inventoryLevels: shopifyConnectionNodesSchema(shopifyInventoryLevelSchema) }).nullable() });
+const inventoryAdjustmentResponseSchema = z.object({
+	inventoryAdjustmentGroup: z.object({
+		createdAt: z.iso.datetime().optional(),
+		reason: z.string(),
+		referenceDocumentUri: z.string().nullable().optional(),
+		changes: z.array(z.object({
+			name: z.string(),
+			delta: z.number()
+		}))
+	}).nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const listInventoryItems = shopifyOperation({
+	id: "list_shopify_inventory_items",
+	name: "List Shopify Inventory Items",
+	description: "List inventory items from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyInventoryItemSchema),
+	run: async (input, credentials) => {
+		return (await createShopifyClient(credentials).graphql(`
+        query ListInventoryItems($first: Int!, $after: String, $query: String) {
+          inventoryItems(first: $first, after: $after, query: $query) {
+            nodes {
+              ${inventoryItemSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listInventoryItemsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).inventoryItems;
+	}
+});
+const getInventoryItem = shopifyOperation({
+	id: "get_shopify_inventory_item",
+	name: "Get Shopify Inventory Item",
+	description: "Retrieve a single Shopify inventory item by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyInventoryItemSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        query GetInventoryItem($id: ID!) {
+          inventoryItem(id: $id) {
+            ${inventoryItemSelection}
+          }
+        }
+      `, getInventoryItemResponseSchema, { variables: { id: input.id } });
+		if (!response.inventoryItem) throw new Error(`Shopify inventory item not found: ${input.id}`);
+		return response.inventoryItem;
+	}
+});
+const getInventoryLevelsForItem = shopifyOperation({
+	id: "get_shopify_inventory_levels_for_item",
+	name: "Get Shopify Inventory Levels For Item",
+	description: "Retrieve inventory levels for a specific Shopify inventory item.",
+	input: z.object({
+		inventoryItemId: shopifyGlobalIdSchema,
+		first: z.number().int().min(1).max(100).optional().default(25),
+		after: z.string().optional()
+	}),
+	output: shopifyConnectionNodesSchema(shopifyInventoryLevelSchema),
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        query GetInventoryLevelsForItem($id: ID!, $first: Int!, $after: String) {
+          inventoryItem(id: $id) {
+            inventoryLevels(first: $first, after: $after) {
+              nodes {
+                ${inventoryLevelSelection}
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+              }
+            }
+          }
+        }
+      `, inventoryLevelsResponseSchema, { variables: {
+			id: input.inventoryItemId,
+			first: input.first,
+			...input.after ? { after: input.after } : {}
+		} });
+		if (!response.inventoryItem) throw new Error(`Shopify inventory item not found for inventory levels lookup: ${input.inventoryItemId}`);
+		return response.inventoryItem.inventoryLevels;
+	}
+});
+const adjustInventoryQuantities = shopifyOperation({
+	id: "adjust_shopify_inventory_quantities",
+	name: "Adjust Shopify Inventory Quantities",
+	description: "Adjust inventory quantities at specific Shopify locations.",
+	needsApproval: true,
+	input: z.object({
+		name: z.string().min(1).default("available"),
+		reason: z.string().min(1),
+		referenceDocumentUri: z.string().optional(),
+		changes: z.array(z.object({
+			inventoryItemId: shopifyGlobalIdSchema,
+			locationId: shopifyGlobalIdSchema,
+			delta: z.number().int()
+		})).min(1)
+	}),
+	output: z.object({
+		createdAt: z.iso.datetime().optional(),
+		reason: z.string(),
+		referenceDocumentUri: z.string().nullable().optional(),
+		changes: z.array(z.object({
+			name: z.string(),
+			delta: z.number()
+		}))
+	}),
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation AdjustInventoryQuantities($input: InventoryAdjustQuantitiesInput!) {
+          inventoryAdjustQuantities(input: $input) {
+            inventoryAdjustmentGroup {
+              createdAt
+              reason
+              referenceDocumentUri
+              changes {
+                name
+                delta
+              }
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ inventoryAdjustQuantities: inventoryAdjustmentResponseSchema }), { variables: { input: {
+			name: input.name,
+			reason: input.reason,
+			referenceDocumentUri: input.referenceDocumentUri,
+			changes: input.changes
+		} } });
+		assertNoUserErrors(response.inventoryAdjustQuantities.userErrors);
+		if (!response.inventoryAdjustQuantities.inventoryAdjustmentGroup) throw new Error("Shopify did not return the inventory adjustment group.");
+		return response.inventoryAdjustQuantities.inventoryAdjustmentGroup;
+	}
+});
+
+//#endregion
+export { adjustInventoryQuantities, getInventoryItem, getInventoryLevelsForItem, listInventoryItems };

package/dist/locations.d.mts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/locations.d.ts
+declare const listLocations: _keystrokehq_core0.Operation<z.ZodObject<{
+  first: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+  after: z.ZodOptional<z.ZodString>;
+  query: z.ZodOptional<z.ZodString>;
+  includeInactive: z.ZodOptional<z.ZodBoolean>;
+  includeLegacy: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    fulfillsOnlineOrders: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  pageInfo: z.ZodObject<{
+    hasNextPage: z.ZodBoolean;
+    hasPreviousPage: z.ZodOptional<z.ZodBoolean>;
+    startCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    endCursor: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getLocation: _keystrokehq_core0.Operation<z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  isActive: z.ZodOptional<z.ZodBoolean>;
+  fulfillsOnlineOrders: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getLocation, listLocations };

package/dist/locations.mjs

@@ -0,0 +1,81 @@
+import { shopifyConnectionNodesSchema, shopifyGlobalIdSchema, shopifyLocationSchema } from "./schemas.mjs";
+import { createShopifyClient } from "./client.mjs";
+import { t as shopifyOperation } from "./factory-DC-gY8L0.mjs";
+import { r as shopifyPageInputSchema } from "./operation-helpers-CKEDIx0o.mjs";
+import { z } from "zod";
+
+//#region src/locations.ts
+const locationSelection = `
+  id
+  name
+  isActive
+  fulfillsOnlineOrders
+`;
+const listLocationsResponseSchema = z.object({ locations: shopifyConnectionNodesSchema(shopifyLocationSchema) });
+const getLocationResponseSchema = z.object({ location: shopifyLocationSchema.nullable() });
+const listLocations = shopifyOperation({
+	id: "list_shopify_locations",
+	name: "List Shopify Locations",
+	description: "List locations from the connected Shopify store.",
+	input: shopifyPageInputSchema.extend({
+		includeInactive: z.boolean().optional(),
+		includeLegacy: z.boolean().optional()
+	}),
+	output: shopifyConnectionNodesSchema(shopifyLocationSchema),
+	run: async (input, credentials) => {
+		return (await createShopifyClient(credentials).graphql(`
+        query ListLocations(
+          $first: Int!
+          $after: String
+          $query: String
+          $includeInactive: Boolean
+          $includeLegacy: Boolean
+        ) {
+          locations(
+            first: $first
+            after: $after
+            query: $query
+            includeInactive: $includeInactive
+            includeLegacy: $includeLegacy
+          ) {
+            nodes {
+              ${locationSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listLocationsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {},
+			...input.includeInactive !== void 0 ? { includeInactive: input.includeInactive } : {},
+			...input.includeLegacy !== void 0 ? { includeLegacy: input.includeLegacy } : {}
+		} })).locations;
+	}
+});
+const getLocation = shopifyOperation({
+	id: "get_shopify_location",
+	name: "Get Shopify Location",
+	description: "Retrieve a single Shopify location by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyLocationSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        query GetLocation($id: ID!) {
+          location(id: $id) {
+            ${locationSelection}
+          }
+        }
+      `, getLocationResponseSchema, { variables: { id: input.id } });
+		if (!response.location) throw new Error(`Shopify location not found: ${input.id}`);
+		return response.location;
+	}
+});
+
+//#endregion
+export { getLocation, listLocations };