@drawbridge/drawbridge-utils 0.0.17 → 0.0.19

package/dist/chunk-CUUQCM5T.js

@@ -0,0 +1,34 @@
+// encrypt.js
+import crypto from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var getKey = () => Buffer.from(process.env.ENCRYPT_CONNECTION_SECRET, "hex");
+var encrypt = (value) => {
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv(ALGORITHM, getKey(), iv);
+  const data = Buffer.concat([
+    cipher.update(JSON.stringify(value), "utf8"),
+    cipher.final()
+  ]);
+  const tag = cipher.getAuthTag();
+  return [iv, tag, data].map((b) => b.toString("hex")).join(":");
+};
+var decrypt = (value) => {
+  if (typeof value !== "string") return value;
+  const [ivHex, tagHex, dataHex] = value.split(":");
+  const decipher = crypto.createDecipheriv(
+    ALGORITHM,
+    getKey(),
+    Buffer.from(ivHex, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(tagHex, "hex"));
+  const result = Buffer.concat([
+    decipher.update(Buffer.from(dataHex, "hex")),
+    decipher.final()
+  ]);
+  return JSON.parse(result.toString("utf8"));
+};
+
+export {
+  encrypt,
+  decrypt
+};

package/dist/encrypt.js

@@ -1,32 +1,7 @@
-// encrypt.js
-import crypto from "crypto";
-var ALGORITHM = "aes-256-gcm";
-var getKey = () => Buffer.from(process.env.ENCRYPT_CONNECTION_SECRET, "hex");
-var encrypt = (value) => {
-  const iv = crypto.randomBytes(12);
-  const cipher = crypto.createCipheriv(ALGORITHM, getKey(), iv);
-  const data = Buffer.concat([
-    cipher.update(JSON.stringify(value), "utf8"),
-    cipher.final()
-  ]);
-  const tag = cipher.getAuthTag();
-  return [iv, tag, data].map((b) => b.toString("hex")).join(":");
-};
-var decrypt = (value) => {
-  if (typeof value !== "string") return value;
-  const [ivHex, tagHex, dataHex] = value.split(":");
-  const decipher = crypto.createDecipheriv(
-    ALGORITHM,
-    getKey(),
-    Buffer.from(ivHex, "hex")
-  );
-  decipher.setAuthTag(Buffer.from(tagHex, "hex"));
-  const result = Buffer.concat([
-    decipher.update(Buffer.from(dataHex, "hex")),
-    decipher.final()
-  ]);
-  return JSON.parse(result.toString("utf8"));
-};
+import {
+  decrypt,
+  encrypt
+} from "./chunk-CUUQCM5T.js";
 export {
   decrypt,
   encrypt

package/dist/shopify.cjs

@@ -0,0 +1,186 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// shopify.js
+var shopify_exports = {};
+__export(shopify_exports, {
+  getAdminToken: () => getAdminToken,
+  refreshAdminToken: () => refreshAdminToken
+});
+module.exports = __toCommonJS(shopify_exports);
+
+// encrypt.js
+var import_crypto = __toESM(require("crypto"), 1);
+var ALGORITHM = "aes-256-gcm";
+var getKey = () => Buffer.from(process.env.ENCRYPT_CONNECTION_SECRET, "hex");
+var encrypt = (value) => {
+  const iv = import_crypto.default.randomBytes(12);
+  const cipher = import_crypto.default.createCipheriv(ALGORITHM, getKey(), iv);
+  const data = Buffer.concat([
+    cipher.update(JSON.stringify(value), "utf8"),
+    cipher.final()
+  ]);
+  const tag = cipher.getAuthTag();
+  return [iv, tag, data].map((b) => b.toString("hex")).join(":");
+};
+var decrypt = (value) => {
+  if (typeof value !== "string") return value;
+  const [ivHex, tagHex, dataHex] = value.split(":");
+  const decipher = import_crypto.default.createDecipheriv(
+    ALGORITHM,
+    getKey(),
+    Buffer.from(ivHex, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(tagHex, "hex"));
+  const result = Buffer.concat([
+    decipher.update(Buffer.from(dataHex, "hex")),
+    decipher.final()
+  ]);
+  return JSON.parse(result.toString("utf8"));
+};
+
+// shopify.js
+var SHOPIFY_ADMIN_API_VERSION = "2025-01";
+var shopifyOAuthFetch = async (url, body) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const error = new Error(response.status + ": " + text);
+    error.status = response.status;
+    throw error;
+  }
+  return response.json();
+};
+var pingShop = async ({ adminAccessToken, domain }) => {
+  const response = await fetch(
+    `https://${domain}/admin/api/${SHOPIFY_ADMIN_API_VERSION}/shop.json`,
+    {
+      headers: {
+        "X-Shopify-Access-Token": adminAccessToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const error = new Error(response.status + ": " + text);
+    error.status = response.status;
+    throw error;
+  }
+};
+var refreshAdminToken = async ({ connection, controller }) => {
+  const settings = decrypt(connection.settings);
+  const { domain, refreshToken } = settings;
+  const data = await shopifyOAuthFetch(
+    `https://${domain}/admin/oauth/access_token`,
+    {
+      grant_type: "refresh_token",
+      client_id: process.env.SHOPIFY_API_KEY,
+      client_secret: process.env.SHOPIFY_API_SECRET,
+      refresh_token: refreshToken
+    }
+  );
+  const adminAccessToken = data.access_token;
+  const newRefreshToken = data.refresh_token;
+  const expiresIn = data.expires_in;
+  const tokenExpiresAt = expiresIn ? new Date(Date.now() + expiresIn * 1e3) : null;
+  await pingShop({ adminAccessToken, domain });
+  const tokenWorkflow = await controller.get({
+    collection: "workflow",
+    query: {
+      connection: connection.id,
+      organization: connection.organization,
+      system: true,
+      title: "Shopify Token Activity"
+    }
+  });
+  await controller.transaction(async (session) => {
+    const options = { session };
+    await controller.update({
+      collection: "connection",
+      data: {
+        $set: {
+          settings: encrypt({
+            ...settings,
+            adminAccessToken,
+            refreshToken: newRefreshToken,
+            tokenExpiresAt
+          })
+        }
+      },
+      options,
+      query: {
+        id: connection.id
+      }
+    });
+    if (tokenWorkflow) {
+      await controller.create({
+        collection: "action",
+        data: {
+          completedAt: /* @__PURE__ */ new Date(),
+          error: null,
+          errorStatus: null,
+          organization: connection.organization,
+          request: null,
+          response: null,
+          slug: "action.shopify.token.refresh",
+          status: "succeeded",
+          trigger: {
+            data: {
+              connection: connection.id
+            },
+            event: "shopify.token"
+          },
+          usage: null,
+          workflow: tokenWorkflow.id
+        },
+        options
+      });
+    }
+    ;
+  });
+  return adminAccessToken;
+};
+var getAdminToken = async ({ connection, controller }) => {
+  const { adminAccessToken, tokenExpiresAt } = decrypt(connection.settings);
+  const needsRefresh = tokenExpiresAt && new Date(tokenExpiresAt) < new Date(Date.now() + 5 * 60 * 1e3);
+  if (needsRefresh) {
+    return refreshAdminToken({ connection, controller });
+  }
+  return adminAccessToken;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAdminToken,
+  refreshAdminToken
+});

package/dist/shopify.d.cts

@@ -0,0 +1,158 @@
+import { decrypt, encrypt } from './encrypt.cjs';
+import 'crypto';
+
+const SHOPIFY_ADMIN_API_VERSION = '2025-01';
+
+const shopifyOAuthFetch = async ( url, body ) => {
+
+	const response = await fetch( url, {
+		method : 'POST',
+		headers : {
+			'Content-Type' : 'application/json'
+		},
+		body : JSON.stringify( body )
+	});
+
+	if( ! response.ok ){
+
+		const text = await response.text().catch( () => '' );
+		const error = new Error( response.status + ': ' + text );
+
+		error.status = response.status;
+
+		throw error;
+
+	}
+
+	return response.json();
+
+};
+
+const pingShop = async ({ adminAccessToken, domain }) => {
+
+	const response = await fetch(
+		`https://${ domain }/admin/api/${ SHOPIFY_ADMIN_API_VERSION }/shop.json`,
+		{
+			headers : {
+				'X-Shopify-Access-Token' : adminAccessToken
+			}
+		}
+	);
+
+	if( ! response.ok ){
+
+		const text = await response.text().catch( () => '' );
+		const error = new Error( response.status + ': ' + text );
+
+		error.status = response.status;
+
+		throw error;
+
+	}
+
+};
+
+const refreshAdminToken = async ({ connection, controller }) => {
+
+	const settings = decrypt( connection.settings );
+	const { domain, refreshToken } = settings;
+
+	const data = await shopifyOAuthFetch(
+		`https://${ domain }/admin/oauth/access_token`,
+		{
+			grant_type : 'refresh_token',
+			client_id : process.env.SHOPIFY_API_KEY,
+			client_secret : process.env.SHOPIFY_API_SECRET,
+			refresh_token : refreshToken
+		}
+	);
+
+	const adminAccessToken = data.access_token;
+	const newRefreshToken = data.refresh_token;
+	const expiresIn = data.expires_in;
+	const tokenExpiresAt = expiresIn ? new Date( Date.now() + ( expiresIn * 1000 ) ) : null;
+
+	await pingShop({ adminAccessToken, domain });
+
+	const tokenWorkflow = await controller.get({
+		collection : 'workflow',
+		query : {
+			connection : connection.id,
+			organization : connection.organization,
+			system : true,
+			title : 'Shopify Token Activity'
+		}
+	});
+
+	await controller.transaction( async ( session ) => {
+
+		const options = { session };
+
+		await controller.update({
+			collection : 'connection',
+			data : {
+				$set : {
+					settings : encrypt({
+						...settings,
+						adminAccessToken,
+						refreshToken : newRefreshToken,
+						tokenExpiresAt
+					})
+				}
+			},
+			options,
+			query : {
+				id : connection.id
+			}
+		});
+
+		if( tokenWorkflow ){
+
+			await controller.create({
+				collection : 'action',
+				data : {
+					completedAt : new Date(),
+					error : null,
+					errorStatus : null,
+					organization : connection.organization,
+					request : null,
+					response : null,
+					slug : 'action.shopify.token.refresh',
+					status : 'succeeded',
+					trigger : {
+						data : {
+							connection : connection.id
+						},
+						event : 'shopify.token'
+					},
+					usage : null,
+					workflow : tokenWorkflow.id
+				},
+				options
+			});
+
+		}
+	} );
+
+	return adminAccessToken;
+
+};
+
+const getAdminToken = async ({ connection, controller }) => {
+
+	const { adminAccessToken, tokenExpiresAt } = decrypt( connection.settings );
+
+	const needsRefresh = tokenExpiresAt &&
+		new Date( tokenExpiresAt ) < new Date( Date.now() + ( 5 * 60 * 1000 ) );
+
+	if( needsRefresh ){
+
+		return refreshAdminToken({ connection, controller });
+
+	}
+
+	return adminAccessToken;
+
+};
+
+export { getAdminToken, refreshAdminToken };

package/dist/shopify.d.ts

@@ -0,0 +1,158 @@
+import { decrypt, encrypt } from './encrypt.js';
+import 'crypto';
+
+const SHOPIFY_ADMIN_API_VERSION = '2025-01';
+
+const shopifyOAuthFetch = async ( url, body ) => {
+
+	const response = await fetch( url, {
+		method : 'POST',
+		headers : {
+			'Content-Type' : 'application/json'
+		},
+		body : JSON.stringify( body )
+	});
+
+	if( ! response.ok ){
+
+		const text = await response.text().catch( () => '' );
+		const error = new Error( response.status + ': ' + text );
+
+		error.status = response.status;
+
+		throw error;
+
+	}
+
+	return response.json();
+
+};
+
+const pingShop = async ({ adminAccessToken, domain }) => {
+
+	const response = await fetch(
+		`https://${ domain }/admin/api/${ SHOPIFY_ADMIN_API_VERSION }/shop.json`,
+		{
+			headers : {
+				'X-Shopify-Access-Token' : adminAccessToken
+			}
+		}
+	);
+
+	if( ! response.ok ){
+
+		const text = await response.text().catch( () => '' );
+		const error = new Error( response.status + ': ' + text );
+
+		error.status = response.status;
+
+		throw error;
+
+	}
+
+};
+
+const refreshAdminToken = async ({ connection, controller }) => {
+
+	const settings = decrypt( connection.settings );
+	const { domain, refreshToken } = settings;
+
+	const data = await shopifyOAuthFetch(
+		`https://${ domain }/admin/oauth/access_token`,
+		{
+			grant_type : 'refresh_token',
+			client_id : process.env.SHOPIFY_API_KEY,
+			client_secret : process.env.SHOPIFY_API_SECRET,
+			refresh_token : refreshToken
+		}
+	);
+
+	const adminAccessToken = data.access_token;
+	const newRefreshToken = data.refresh_token;
+	const expiresIn = data.expires_in;
+	const tokenExpiresAt = expiresIn ? new Date( Date.now() + ( expiresIn * 1000 ) ) : null;
+
+	await pingShop({ adminAccessToken, domain });
+
+	const tokenWorkflow = await controller.get({
+		collection : 'workflow',
+		query : {
+			connection : connection.id,
+			organization : connection.organization,
+			system : true,
+			title : 'Shopify Token Activity'
+		}
+	});
+
+	await controller.transaction( async ( session ) => {
+
+		const options = { session };
+
+		await controller.update({
+			collection : 'connection',
+			data : {
+				$set : {
+					settings : encrypt({
+						...settings,
+						adminAccessToken,
+						refreshToken : newRefreshToken,
+						tokenExpiresAt
+					})
+				}
+			},
+			options,
+			query : {
+				id : connection.id
+			}
+		});
+
+		if( tokenWorkflow ){
+
+			await controller.create({
+				collection : 'action',
+				data : {
+					completedAt : new Date(),
+					error : null,
+					errorStatus : null,
+					organization : connection.organization,
+					request : null,
+					response : null,
+					slug : 'action.shopify.token.refresh',
+					status : 'succeeded',
+					trigger : {
+						data : {
+							connection : connection.id
+						},
+						event : 'shopify.token'
+					},
+					usage : null,
+					workflow : tokenWorkflow.id
+				},
+				options
+			});
+
+		}
+	} );
+
+	return adminAccessToken;
+
+};
+
+const getAdminToken = async ({ connection, controller }) => {
+
+	const { adminAccessToken, tokenExpiresAt } = decrypt( connection.settings );
+
+	const needsRefresh = tokenExpiresAt &&
+		new Date( tokenExpiresAt ) < new Date( Date.now() + ( 5 * 60 * 1000 ) );
+
+	if( needsRefresh ){
+
+		return refreshAdminToken({ connection, controller });
+
+	}
+
+	return adminAccessToken;
+
+};
+
+export { getAdminToken, refreshAdminToken };

package/dist/shopify.js

@@ -0,0 +1,124 @@
+import {
+  decrypt,
+  encrypt
+} from "./chunk-CUUQCM5T.js";
+
+// shopify.js
+var SHOPIFY_ADMIN_API_VERSION = "2025-01";
+var shopifyOAuthFetch = async (url, body) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const error = new Error(response.status + ": " + text);
+    error.status = response.status;
+    throw error;
+  }
+  return response.json();
+};
+var pingShop = async ({ adminAccessToken, domain }) => {
+  const response = await fetch(
+    `https://${domain}/admin/api/${SHOPIFY_ADMIN_API_VERSION}/shop.json`,
+    {
+      headers: {
+        "X-Shopify-Access-Token": adminAccessToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const error = new Error(response.status + ": " + text);
+    error.status = response.status;
+    throw error;
+  }
+};
+var refreshAdminToken = async ({ connection, controller }) => {
+  const settings = decrypt(connection.settings);
+  const { domain, refreshToken } = settings;
+  const data = await shopifyOAuthFetch(
+    `https://${domain}/admin/oauth/access_token`,
+    {
+      grant_type: "refresh_token",
+      client_id: process.env.SHOPIFY_API_KEY,
+      client_secret: process.env.SHOPIFY_API_SECRET,
+      refresh_token: refreshToken
+    }
+  );
+  const adminAccessToken = data.access_token;
+  const newRefreshToken = data.refresh_token;
+  const expiresIn = data.expires_in;
+  const tokenExpiresAt = expiresIn ? new Date(Date.now() + expiresIn * 1e3) : null;
+  await pingShop({ adminAccessToken, domain });
+  const tokenWorkflow = await controller.get({
+    collection: "workflow",
+    query: {
+      connection: connection.id,
+      organization: connection.organization,
+      system: true,
+      title: "Shopify Token Activity"
+    }
+  });
+  await controller.transaction(async (session) => {
+    const options = { session };
+    await controller.update({
+      collection: "connection",
+      data: {
+        $set: {
+          settings: encrypt({
+            ...settings,
+            adminAccessToken,
+            refreshToken: newRefreshToken,
+            tokenExpiresAt
+          })
+        }
+      },
+      options,
+      query: {
+        id: connection.id
+      }
+    });
+    if (tokenWorkflow) {
+      await controller.create({
+        collection: "action",
+        data: {
+          completedAt: /* @__PURE__ */ new Date(),
+          error: null,
+          errorStatus: null,
+          organization: connection.organization,
+          request: null,
+          response: null,
+          slug: "action.shopify.token.refresh",
+          status: "succeeded",
+          trigger: {
+            data: {
+              connection: connection.id
+            },
+            event: "shopify.token"
+          },
+          usage: null,
+          workflow: tokenWorkflow.id
+        },
+        options
+      });
+    }
+    ;
+  });
+  return adminAccessToken;
+};
+var getAdminToken = async ({ connection, controller }) => {
+  const { adminAccessToken, tokenExpiresAt } = decrypt(connection.settings);
+  const needsRefresh = tokenExpiresAt && new Date(tokenExpiresAt) < new Date(Date.now() + 5 * 60 * 1e3);
+  if (needsRefresh) {
+    return refreshAdminToken({ connection, controller });
+  }
+  return adminAccessToken;
+};
+export {
+  getAdminToken,
+  refreshAdminToken
+};

package/package.json

@@ -4,7 +4,7 @@
     "axios": "1.16.0",
     "currency-codes": "2.2.0",
     "nanoid": "3.3.8",
-    "qs": "6.15.1",
+    "qs": "6.15.2",
     "slugify": "1.6.6",
     "tsup": "8.5.1",
     "typescript": "5.9.3"
@@ -81,5 +81,5 @@
     "build": "tsup && npm publish"
   },
   "types": "dist/index.d.ts",
-  "version": "0.0.17"
+  "version": "0.0.19"
 }