@stardeck-customer-apps/testing 0.3.0 → 0.4.0

package/dist/setup.mjs

@@ -16,6 +16,16 @@ var state = globalSingleton("state", () => ({
   emailCounter: 0,
   identities: /* @__PURE__ */ new Map(),
   identityLinks: [],
+  checkouts: [],
+  checkoutCounter: 0,
+  sessionStatuses: /* @__PURE__ */ new Map(),
+  paymentLinks: /* @__PURE__ */ new Map(),
+  products: [],
+  uploads: [],
+  uploadCounter: 0,
+  storageFiles: /* @__PURE__ */ new Map(),
+  presignPending: /* @__PURE__ */ new Map(),
+  messages: [],
   allowNetwork: false
 }));
 function requireDb() {
@@ -31,13 +41,16 @@ function requireDb() {
 var TEST_DOMAIN_SUFFIX = ".stardeck.test";
 var CONTROL_PLANE_TEST_URL = "https://control-plane.stardeck.test";
 var DATA_STORE_TEST_HOST = "db.stardeck.test";
+var STORAGE_TEST_URL = "https://storage.stardeck.test";
+var STORAGE_TEST_HOST = "storage.stardeck.test";
 var TEST_ENV_DEFAULTS = {
   CONTROL_PLANE_URL: CONTROL_PLANE_TEST_URL,
   DEPLOYMENT_SECRET: "stardeck-test-deployment-secret",
   ORGANIZATION_ID: "00000000-0000-4000-8000-00000000000a",
   PROJECT_ID: "00000000-0000-4000-8000-00000000000b",
   DEPLOYMENT_ID: "00000000-0000-4000-8000-00000000000c",
-  DATA_STORE_URL: `postgresql://test:test@${DATA_STORE_TEST_HOST}/main`
+  DATA_STORE_URL: `postgresql://test:test@${DATA_STORE_TEST_HOST}/main`,
+  STORAGE_URL: STORAGE_TEST_URL
 };
 
 // src/simulator/hmac.ts
@@ -85,6 +98,13 @@ function success(data) {
 function failure(error, status = 400) {
   return json({ success: false, error }, status);
 }
+async function readJsonBody(request) {
+  try {
+    return await request.json();
+  } catch {
+    return {};
+  }
+}
 
 // src/simulator/data-store.ts
 function quoteIdent(name) {
@@ -565,13 +585,6 @@ function now() {
 function linksFor(identityId) {
   return state.identityLinks.filter((l) => l.identityId === identityId);
 }
-async function readBody(request) {
-  try {
-    return await request.json();
-  } catch {
-    return {};
-  }
-}
 function handleList(request) {
   const typeParam = new URL(request.url).searchParams.get("type");
   const type = typeParam === "person" || typeParam === "account" ? typeParam : void 0;
@@ -579,7 +592,7 @@ function handleList(request) {
   return success({ identities: type ? identities.filter((i) => i.type === type) : identities });
 }
 async function handleCreate(request) {
-  const body = await readBody(request);
+  const body = await readJsonBody(request);
   const type = body.type;
   if (type !== "person" && type !== "account") {
     return failure("type must be 'person' or 'account'");
@@ -616,7 +629,7 @@ function handleGet(identityId) {
 async function handleUpdate(identityId, request) {
   const identity = state.identities.get(identityId);
   if (!identity) return failure("identity not found", 404);
-  const body = await readBody(request);
+  const body = await readJsonBody(request);
   if (body.displayName !== void 0) {
     identity.displayName = body.displayName;
   }
@@ -638,7 +651,7 @@ async function handleAttachLink(identityId, request) {
   if (identity.status !== "active") {
     return failure("links attach only to active persons");
   }
-  const body = await readBody(request);
+  const body = await readJsonBody(request);
   const kind = body.kind;
   const externalId = body.externalId;
   if (typeof kind !== "string" || !LINK_KINDS.has(kind)) {
@@ -681,6 +694,447 @@ async function handleIdentitiesRequest(request, subPath) {
   return failure(`No identities simulator for ${method} .../identities${subPath}`, 404);
 }
 
+// src/simulator/payments.ts
+import crypto5 from "crypto";
+
+// src/next/headers-shim.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestScopeStorage = globalSingleton(
+  "request-scope",
+  () => new AsyncLocalStorage()
+);
+
+// src/simulator/webhook-signing.ts
+import crypto4 from "crypto";
+
+// src/simulator/payments.ts
+function payErr(error, status = 400, code) {
+  return json(code ? { error, code } : { error }, status);
+}
+function nextCheckoutId() {
+  state.checkoutCounter += 1;
+  return `cs_test_${state.checkoutCounter}`;
+}
+function nextPaymentLinkId() {
+  state.checkoutCounter += 1;
+  return `plink_test_${state.checkoutCounter}`;
+}
+function seedStripeSession(id, body) {
+  const lineItems = body.lineItems ?? [];
+  let amountTotal = null;
+  let currency = null;
+  if (lineItems.length > 0) {
+    amountTotal = lineItems.reduce(
+      (sum, item) => sum + (item.priceData?.unitAmount ?? 0) * (item.quantity ?? 1),
+      0
+    );
+    currency = lineItems[0].priceData?.currency ?? null;
+  }
+  state.sessionStatuses.set(id, {
+    id,
+    status: "open",
+    paymentStatus: "unpaid",
+    mode: body.mode ?? "payment",
+    amountTotal,
+    currency,
+    customerEmail: body.customerEmail ? String(body.customerEmail) : null,
+    metadata: body.metadata ?? {},
+    expiresAt: Math.floor(Date.now() / 1e3) + 3600
+  });
+}
+function seedBeamLink(id, body, merchantId) {
+  const order = body.order;
+  state.paymentLinks.set(id, {
+    paymentLinkId: id,
+    merchantId,
+    url: `https://beam.test/pay/${id}`,
+    status: "ACTIVE",
+    order: {
+      netAmount: Number(order?.netAmount ?? 0),
+      currency: String(order?.currency ?? "THB"),
+      description: String(order?.description ?? ""),
+      referenceId: order?.referenceId ? String(order.referenceId) : void 0,
+      internalNote: order?.internalNote ? String(order.internalNote) : void 0,
+      orderItems: order?.orderItems
+    },
+    redirectUrl: body.redirectUrl ? String(body.redirectUrl) : void 0,
+    linkSettings: body.linkSettings,
+    collectDeliveryAddress: body.collectDeliveryAddress === true
+  });
+}
+async function handlePaymentsRequest(request, url) {
+  const pathname = url.pathname;
+  if (/\/bolt-connections/.test(pathname) || /\/bolt-intents/.test(pathname) || /\/charges(\/|$)/.test(pathname) || /\/billing-portal$/.test(pathname)) {
+    return payErr("Not found", 404, "NOT_FOUND");
+  }
+  const beamProductsMatch = pathname.match(
+    /^\/api\/store\/beam\/([^/]+)\/payment-links(?:\/([^/]+))?$/
+  );
+  if (beamProductsMatch) {
+    const merchantId = beamProductsMatch[1];
+    const linkId = beamProductsMatch[2];
+    if (!linkId && request.method === "POST") {
+      const body = await readJsonBody(request);
+      const id = nextPaymentLinkId();
+      const checkoutUrl = `https://beam.test/pay/${id}`;
+      const captured = {
+        id,
+        url: checkoutUrl,
+        provider: "beam",
+        options: body,
+        metadata: body.metadata,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      state.checkouts.push(captured);
+      seedBeamLink(id, body, merchantId);
+      return json({ id, url: checkoutUrl });
+    }
+    if (linkId && request.method === "GET") {
+      const link = state.paymentLinks.get(linkId);
+      if (!link) return payErr("Payment link not found", 404, "NOT_FOUND");
+      return json({ paymentLink: link });
+    }
+  }
+  const stripeStoreMatch = pathname.match(/^\/api\/store\/([^/]+)\/(.+)$/);
+  if (stripeStoreMatch) {
+    const accountId = stripeStoreMatch[1];
+    const subPath = stripeStoreMatch[2];
+    if (accountId === "beam") {
+      return payErr(`No payments simulator for ${request.method} ${pathname}`, 404);
+    }
+    if (subPath === "products" && request.method === "GET") {
+      return json({ products: state.products });
+    }
+    const productMatch = subPath.match(/^products\/([^/]+)$/);
+    if (productMatch && request.method === "GET") {
+      const product = state.products.find((p) => p.id === productMatch[1]);
+      if (!product) return payErr("Product not found", 404, "NOT_FOUND");
+      return json({ product });
+    }
+    if (subPath === "checkout" && request.method === "POST") {
+      const body = await readJsonBody(request);
+      const id = nextCheckoutId();
+      const checkoutUrl = `https://checkout.stripe.test/c/pay/${id}`;
+      const captured = {
+        id,
+        url: checkoutUrl,
+        provider: "stripe",
+        options: body,
+        mode: body.mode,
+        metadata: body.metadata,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      state.checkouts.push(captured);
+      seedStripeSession(id, body);
+      return json({ id, url: checkoutUrl });
+    }
+    const sessionMatch = subPath.match(/^checkout-sessions\/([^/]+)$/);
+    if (sessionMatch && request.method === "GET") {
+      const session = state.sessionStatuses.get(sessionMatch[1]);
+      if (!session) return payErr("Checkout session not found", 404, "NOT_FOUND");
+      return json({ session });
+    }
+  }
+  return payErr(`No payments simulator for ${request.method} ${pathname}`, 404);
+}
+
+// src/simulator/storage.ts
+import crypto6 from "crypto";
+function storageErr(error, status = 400) {
+  return json({ error }, status);
+}
+function fileExtension(filename) {
+  const dot = filename.lastIndexOf(".");
+  return dot === -1 ? "bin" : filename.slice(dot + 1);
+}
+function buildKey(fileId, filename) {
+  const orgId = process.env.ORGANIZATION_ID ?? TEST_ENV_DEFAULTS.ORGANIZATION_ID;
+  const projectId = process.env.PROJECT_ID ?? TEST_ENV_DEFAULTS.PROJECT_ID;
+  const deploymentId = process.env.DEPLOYMENT_ID ?? TEST_ENV_DEFAULTS.DEPLOYMENT_ID;
+  return `${orgId}/${projectId}/${deploymentId}/${fileId}.${fileExtension(filename)}`;
+}
+function buildUrl(key) {
+  return `${STORAGE_TEST_URL}/files/${key}`;
+}
+function toUploadResponse(record) {
+  return {
+    id: record.id,
+    key: record.key,
+    filename: record.filename,
+    contentType: record.contentType,
+    sizeBytes: record.sizeBytes,
+    url: record.url,
+    uploadedAt: record.uploadedAt,
+    isPublic: record.isPublic,
+    metadata: record.metadata
+  };
+}
+function captureUpload(record, method, path) {
+  const captured = {
+    id: record.id,
+    key: record.key,
+    filename: record.filename,
+    contentType: record.contentType,
+    sizeBytes: record.sizeBytes,
+    url: record.url,
+    uploadedAt: record.uploadedAt,
+    isPublic: record.isPublic,
+    metadata: record.metadata,
+    method,
+    path
+  };
+  state.uploads.push(captured);
+}
+function createFileRecord(input) {
+  state.uploadCounter += 1;
+  const id = `file_test_${state.uploadCounter}`;
+  const key = buildKey(id, input.filename);
+  return {
+    id,
+    key,
+    filename: input.filename,
+    contentType: input.contentType,
+    sizeBytes: input.sizeBytes,
+    url: buildUrl(key),
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: input.metadata,
+    isPublic: input.isPublic,
+    deleted: false
+  };
+}
+function activeFiles() {
+  return [...state.storageFiles.values()].filter((f) => !f.deleted);
+}
+async function handleStorageRequest(request, url) {
+  const pathname = url.pathname;
+  if (pathname.startsWith("/upload/presign/multipart")) {
+    return storageErr("Not found", 404);
+  }
+  const presignedPutMatch = pathname.match(/^\/presigned\/([^/]+)$/);
+  if (presignedPutMatch && request.method === "PUT") {
+    const fileId = presignedPutMatch[1];
+    if (!state.presignPending.has(fileId)) {
+      return storageErr("Presign session not found", 404);
+    }
+    return new Response(null, {
+      status: 200,
+      headers: { etag: `"${crypto6.randomUUID()}"` }
+    });
+  }
+  if (pathname === "/upload/presign/complete" && request.method === "POST") {
+    const body = await readJsonBody(request);
+    const fileId = String(body.fileId ?? "");
+    const pending = state.presignPending.get(fileId);
+    if (!pending) return storageErr("Presign session not found", 404);
+    const record = {
+      id: fileId,
+      key: pending.key,
+      filename: pending.fileName,
+      contentType: pending.contentType,
+      sizeBytes: pending.sizeBytes,
+      url: buildUrl(pending.key),
+      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: pending.metadata,
+      isPublic: pending.isPublic,
+      deleted: false
+    };
+    state.storageFiles.set(record.id, record);
+    state.presignPending.delete(fileId);
+    captureUpload(record, "POST", "/upload/presign/complete");
+    return json(toUploadResponse(record));
+  }
+  if (pathname === "/upload/presign" && request.method === "POST") {
+    const body = await readJsonBody(request);
+    const fileName = String(body.fileName ?? "upload.bin");
+    const contentType = String(body.contentType ?? "application/octet-stream");
+    const sizeBytes = Number(body.sizeBytes ?? 0);
+    const isPublic = body.isPublic !== false;
+    const metadata = body.metadata;
+    state.uploadCounter += 1;
+    const fileId = `file_test_${state.uploadCounter}`;
+    const key = buildKey(fileId, fileName);
+    state.presignPending.set(fileId, {
+      fileName,
+      contentType,
+      sizeBytes,
+      isPublic,
+      metadata,
+      key
+    });
+    return json({
+      fileId,
+      key,
+      presignedUrl: `${STORAGE_TEST_URL}/presigned/${fileId}`,
+      contentType,
+      expiresIn: 3600
+    });
+  }
+  if (pathname === "/upload" && request.method === "POST") {
+    const isPublic = url.searchParams.get("isPublic") !== "false";
+    const formData = await request.formData();
+    const file = formData.get("file");
+    if (!(file instanceof Blob)) {
+      return storageErr("file is required");
+    }
+    const filename = formData.get("filename") ?? (file instanceof File ? file.name : "upload.bin");
+    const metadataRaw = formData.get("metadata");
+    let metadata;
+    if (typeof metadataRaw === "string" && metadataRaw) {
+      try {
+        metadata = JSON.parse(metadataRaw);
+      } catch {
+        return storageErr("metadata must be valid JSON");
+      }
+    }
+    const record = createFileRecord({
+      filename,
+      contentType: file.type || "application/octet-stream",
+      sizeBytes: file.size,
+      isPublic,
+      metadata
+    });
+    state.storageFiles.set(record.id, record);
+    captureUpload(record, "POST", "/upload");
+    return json(toUploadResponse(record));
+  }
+  const fileMatch = pathname.match(/^\/api\/files\/([^/]+)$/);
+  if (fileMatch) {
+    const fileId = fileMatch[1];
+    const record = state.storageFiles.get(fileId);
+    if (!record || record.deleted) {
+      return storageErr("File not found", 404);
+    }
+    if (request.method === "GET") {
+      return json(toUploadResponse(record));
+    }
+    if (request.method === "PATCH") {
+      const body = await readJsonBody(request);
+      if (body.fileName !== void 0) record.filename = String(body.fileName);
+      if (body.metadata !== void 0) {
+        record.metadata = body.metadata;
+      }
+      if (body.isPublic !== void 0) record.isPublic = body.isPublic === true;
+      return json(toUploadResponse(record));
+    }
+    if (request.method === "DELETE") {
+      record.deleted = true;
+      return json({ success: true });
+    }
+  }
+  if (pathname === "/api/files" && request.method === "GET") {
+    const parseParam = (raw, fallback, min) => {
+      const n = Number(raw);
+      return Number.isFinite(n) && n >= min ? Math.floor(n) : fallback;
+    };
+    const limit = parseParam(url.searchParams.get("limit"), 50, 1);
+    const offset = parseParam(url.searchParams.get("offset"), 0, 0);
+    const prefix = url.searchParams.get("prefix") ?? "";
+    let files = activeFiles();
+    if (prefix) {
+      files = files.filter((f) => f.key.startsWith(prefix) || f.filename.startsWith(prefix));
+    }
+    const total = files.length;
+    const slice = files.slice(offset, offset + limit);
+    return json({
+      files: slice.map((f) => toUploadResponse(f)),
+      total,
+      limit,
+      offset,
+      hasMore: offset + slice.length < total
+    });
+  }
+  return storageErr(`No storage simulator for ${request.method} ${pathname}`, 404);
+}
+
+// src/simulator/messaging.ts
+import crypto7 from "crypto";
+function captureMessage(channel, recipient, body, connectionId) {
+  const message = {
+    channel,
+    recipient,
+    body: {
+      text: body.text ? String(body.text) : void 0,
+      blocks: body.blocks,
+      threadTs: body.threadTs ? String(body.threadTs) : void 0,
+      messagingType: body.messagingType ? String(body.messagingType) : void 0,
+      tag: body.tag ? String(body.tag) : void 0
+    },
+    connectionId,
+    sentAt: /* @__PURE__ */ new Date()
+  };
+  state.messages.push(message);
+}
+async function handleMessagingRequest(request, channel, subPath) {
+  const method = request.method;
+  if ((subPath === "" || subPath === "/" || subPath === "/connections") && method === "GET") {
+    return success({ connections: [] });
+  }
+  if (channel === "slack" && subPath === "/send" && method === "POST") {
+    const body = await readJsonBody(request);
+    if (!body.text && !body.blocks) {
+      return failure("text or blocks is required");
+    }
+    const slackChannel = String(body.channel ?? "");
+    if (!slackChannel) {
+      return failure("channel is required");
+    }
+    captureMessage(
+      "slack",
+      slackChannel,
+      body,
+      body.connectionId ? String(body.connectionId) : void 0
+    );
+    return success({
+      ok: true,
+      ts: `${Date.now()}.${crypto7.randomUUID().slice(0, 6)}`,
+      channel: slackChannel
+    });
+  }
+  if (channel === "line" && subPath === "/push" && method === "POST") {
+    const body = await readJsonBody(request);
+    const userId = String(body.userId ?? "");
+    const message = body.message;
+    if (!userId) return failure("userId is required");
+    if (!message || message.type !== "text" || !message.text) {
+      return failure("message must be { type: 'text', text: string }");
+    }
+    if (message.text.length > 5e3) {
+      return failure("message text exceeds maximum length");
+    }
+    captureMessage(
+      "line",
+      userId,
+      { text: message.text },
+      body.connectionId ? String(body.connectionId) : void 0
+    );
+    return success({ success: true });
+  }
+  if (channel === "facebook" && subPath === "/send" && method === "POST") {
+    const body = await readJsonBody(request);
+    const recipientId = String(body.recipientId ?? "");
+    const message = body.message;
+    if (!recipientId) return failure("recipientId is required");
+    if (!message || message.type !== "text" || !message.text) {
+      return failure("message must be { type: 'text', text: string }");
+    }
+    if (message.text.length > 2e3) {
+      return failure("message text exceeds maximum length");
+    }
+    captureMessage(
+      "facebook",
+      recipientId,
+      {
+        text: message.text,
+        messagingType: body.messagingType ? String(body.messagingType) : void 0,
+        tag: body.tag ? String(body.tag) : void 0
+      },
+      body.connectionId ? String(body.connectionId) : void 0
+    );
+    return success({ success: true });
+  }
+  return failure(`No messaging simulator for ${method} .../integrations/${channel}${subPath}`, 404);
+}
+
 // src/simulator/router.ts
 var fetchHolder = globalSingleton("fetch-holder", () => ({
   originalFetch: null
@@ -688,6 +1142,21 @@ var fetchHolder = globalSingleton("fetch-holder", () => ({
 function isLocalHost(hostname) {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0";
 }
+function requiresDeploymentHmac(request, url) {
+  const isStorageHost = url.hostname === STORAGE_TEST_HOST;
+  const isPresignedPut = isStorageHost && request.method === "PUT" && /^\/presigned\/[^/]+$/.test(url.pathname);
+  if (isStorageHost) {
+    return !isPresignedPut;
+  }
+  const dataStoreMatch = url.pathname.match(/^\/api\/data-stores\/[^/]+(\/.*)?$/);
+  const isEmail = url.pathname === "/api/email/send";
+  const identitiesMatch = url.pathname.match(/^\/api\/deployments\/[^/]+\/identities(\/.*)?$/);
+  const storeMatch = url.pathname.match(/^\/api\/store\//);
+  const messagingMatch = url.pathname.match(
+    /^\/api\/deployments\/[^/]+\/integrations\/(slack|line|facebook)(\/.*)?$/
+  );
+  return !!(dataStoreMatch || isEmail || identitiesMatch || storeMatch || messagingMatch);
+}
 async function handleSimulatedRequest(request, url) {
   if (url.pathname === "/sql") {
     return handleNeonSql(requireDb(), request);
@@ -699,7 +1168,12 @@ async function handleSimulatedRequest(request, url) {
   const dataStoreMatch = url.pathname.match(/^\/api\/data-stores\/[^/]+(\/.*)?$/);
   const isEmail = url.pathname === "/api/email/send";
   const identitiesMatch = url.pathname.match(/^\/api\/deployments\/[^/]+\/identities(\/.*)?$/);
-  if (dataStoreMatch || isEmail || identitiesMatch) {
+  const storeMatch = url.pathname.match(/^\/api\/store\//);
+  const messagingMatch = url.pathname.match(
+    /^\/api\/deployments\/[^/]+\/integrations\/(slack|line|facebook)(\/.*)?$/
+  );
+  const isStorageHost = url.hostname === STORAGE_TEST_HOST;
+  if (requiresDeploymentHmac(request, url)) {
     const authHeader = request.headers.get("X-Stardeck-Auth");
     if (!authHeader) {
       return failure("Missing authentication header", 401);
@@ -709,34 +1183,44 @@ async function handleSimulatedRequest(request, url) {
       return failure("Invalid authentication", 401);
     }
   }
+  if (isStorageHost) {
+    return handleStorageRequest(request, url);
+  }
   if (isEmail && request.method === "POST") {
     return handleEmailSend(request);
   }
   if (identitiesMatch) {
     return handleIdentitiesRequest(request, identitiesMatch[1] ?? "");
   }
+  if (storeMatch) {
+    return handlePaymentsRequest(request, url);
+  }
+  if (messagingMatch) {
+    const channel = messagingMatch[1];
+    return handleMessagingRequest(request, channel, messagingMatch[2] ?? "");
+  }
   if (dataStoreMatch) {
     const subPath = dataStoreMatch[1] ?? "";
     const db = requireDb();
-    const readBody2 = async () => await request.json();
+    const readBody = async () => await request.json();
     if (subPath === "/query" && request.method === "POST") {
-      return handleQuery(db, await readBody2());
+      return handleQuery(db, await readBody());
     }
     if (subPath === "/mutate" && request.method === "POST") {
-      return handleMutate(db, await readBody2());
+      return handleMutate(db, await readBody());
     }
     if (subPath === "/schema" && request.method === "GET") {
       return handleGetSchema(db);
     }
     if (subPath === "/schema/tables" && request.method === "POST") {
-      return handleCreateTable(db, await readBody2());
+      return handleCreateTable(db, await readBody());
     }
     if (subPath === "/schema/columns" && request.method === "POST") {
-      return handleAddColumn(db, await readBody2());
+      return handleAddColumn(db, await readBody());
     }
   }
   return failure(
-    `[stardeck-testing] No simulator for ${request.method} ${url.pathname}. Supported: data-store query/mutate/schema, email send, identities CRUD, auth verify/refresh, Neon /sql.`,
+    `[stardeck-testing] No simulator for ${request.method} ${url.pathname}. Supported: data-store query/mutate/schema, email send, identities CRUD, payments store/checkout, storage upload/files, messaging send, auth verify/refresh, Neon /sql.`,
     404
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stardeck-customer-apps/testing",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Vitest test harness for Stardeck customer apps — in-process Postgres (PGlite) plus a control-plane simulator so the real Stardeck SDKs run unmodified in tests",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -62,11 +62,12 @@
   "author": "Stardeck",
   "license": "MIT",
   "dependencies": {
-    "@electric-sql/pglite": "^0.3.0",
-    "@stardeck-customer-apps/core": "*"
+    "@electric-sql/pglite": "^0.3.0"
   },
   "peerDependencies": {
     "@stardeck-customer-apps/integrations-sdk": ">=1.6.0",
+    "@stardeck-customer-apps/payments-sdk": ">=0.1.0",
+    "@stardeck-customer-apps/storage-sdk": ">=0.1.0",
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "vitest": ">=2.0.0"
   },
@@ -74,6 +75,12 @@
     "@stardeck-customer-apps/integrations-sdk": {
       "optional": true
     },
+    "@stardeck-customer-apps/payments-sdk": {
+      "optional": true
+    },
+    "@stardeck-customer-apps/storage-sdk": {
+      "optional": true
+    },
     "next": {
       "optional": true
     }
@@ -84,6 +91,8 @@
     "@stardeck-customer-apps/data-store-sdk": "*",
     "@stardeck-customer-apps/email-sdk": "*",
     "@stardeck-customer-apps/integrations-sdk": "*",
+    "@stardeck-customer-apps/payments-sdk": "*",
+    "@stardeck-customer-apps/storage-sdk": "*",
     "@stardeck-customer-apps/tsconfig": "*",
     "@types/node": "^24.10.1",
     "kysely": "^0.27.0",