paykitjs 0.0.1-alpha.1

package/dist/product/product.service.js

@@ -0,0 +1,127 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { feature, product, productFeature } from "../database/schema.js";
+import { generateId } from "../core/utils.js";
+import { and, desc, eq, sql } from "drizzle-orm";
+//#region src/product/product.service.ts
+function withProviderInfo(storedProduct, providerId) {
+	const providerInfo = (storedProduct.provider ?? {})[providerId];
+	return {
+		...storedProduct,
+		providerProductId: providerInfo?.productId ?? null,
+		providerPriceId: providerInfo?.priceId ?? null
+	};
+}
+async function upsertFeature(database, input) {
+	const now = /* @__PURE__ */ new Date();
+	const row = (await database.insert(feature).values({
+		createdAt: now,
+		id: input.id,
+		type: input.type,
+		updatedAt: now
+	}).onConflictDoUpdate({
+		target: feature.id,
+		set: {
+			type: input.type,
+			updatedAt: now
+		}
+	}).returning())[0];
+	if (!row) throw PayKitError.from("INTERNAL_SERVER_ERROR", PAYKIT_ERROR_CODES.FEATURE_UPSERT_FAILED, `Failed to upsert feature "${input.id}"`);
+	return row;
+}
+async function getLatestProduct(database, id) {
+	return await database.query.product.findFirst({
+		where: eq(product.id, id),
+		orderBy: (p, { desc }) => [desc(p.version)]
+	}) ?? null;
+}
+async function getLatestProductSnapshot(database, id) {
+	const storedProduct = await getLatestProduct(database, id);
+	if (!storedProduct) return null;
+	return {
+		features: await getProductFeatures(database, storedProduct.internalId),
+		product: storedProduct
+	};
+}
+async function insertProductVersion(database, input) {
+	const now = /* @__PURE__ */ new Date();
+	const internalId = generateId("prod");
+	await database.insert(product).values({
+		createdAt: now,
+		group: input.group,
+		hash: input.hash,
+		id: input.id,
+		internalId,
+		isDefault: input.isDefault,
+		name: input.name,
+		priceAmount: input.priceAmount,
+		priceInterval: input.priceInterval,
+		updatedAt: now,
+		version: input.version
+	});
+	return {
+		createdAt: now,
+		group: input.group,
+		hash: input.hash,
+		id: input.id,
+		internalId,
+		isDefault: input.isDefault,
+		name: input.name,
+		priceAmount: input.priceAmount,
+		priceInterval: input.priceInterval,
+		provider: {},
+		updatedAt: now,
+		version: input.version
+	};
+}
+async function updateProductName(database, internalId, name) {
+	await database.update(product).set({
+		name,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(product.internalId, internalId));
+}
+async function getProductFeatures(database, productInternalId) {
+	return await database.query.productFeature.findMany({
+		where: eq(productFeature.productInternalId, productInternalId),
+		orderBy: (pf) => [pf.featureId]
+	});
+}
+async function replaceProductFeatures(database, input) {
+	await database.delete(productFeature).where(eq(productFeature.productInternalId, input.productInternalId));
+	if (input.features.length === 0) return;
+	const now = /* @__PURE__ */ new Date();
+	for (const planFeature of input.features) await database.insert(productFeature).values({
+		config: planFeature.config,
+		createdAt: now,
+		featureId: planFeature.id,
+		limit: planFeature.limit,
+		productInternalId: input.productInternalId,
+		resetInterval: planFeature.resetInterval,
+		updatedAt: now
+	});
+}
+async function getProviderProduct(database, productInternalId, providerId) {
+	const row = await database.query.product.findFirst({ where: eq(product.internalId, productInternalId) });
+	if (!row) return null;
+	return row.provider[providerId] ?? null;
+}
+async function upsertProviderProduct(database, input) {
+	const existing = await database.query.product.findFirst({ where: eq(product.internalId, input.productInternalId) });
+	if (!existing) return;
+	const providerMap = existing.provider ?? {};
+	providerMap[input.providerId] = {
+		productId: input.providerProductId,
+		priceId: input.providerPriceId ?? null
+	};
+	await database.update(product).set({ provider: providerMap }).where(eq(product.internalId, input.productInternalId));
+}
+async function getDefaultProductInGroup(database, group) {
+	return await database.query.product.findFirst({
+		where: and(eq(product.group, group), eq(product.isDefault, true)),
+		orderBy: [desc(product.version)]
+	}) ?? null;
+}
+async function getProductByProviderPriceId(database, input) {
+	return await database.query.product.findFirst({ where: sql`${product.provider}->${input.providerId}->>'priceId' = ${input.providerPriceId}` }) ?? null;
+}
+//#endregion
+export { getDefaultProductInGroup, getLatestProduct, getLatestProductSnapshot, getProductByProviderPriceId, getProviderProduct, insertProductVersion, replaceProductFeatures, updateProductName, upsertFeature, upsertProviderProduct, withProviderInfo };

package/dist/providers/provider.d.ts

@@ -0,0 +1,159 @@
+import { NormalizedWebhookEvent } from "../types/events.js";
+
+//#region src/providers/provider.d.ts
+interface ProviderCustomer {
+  frozenTime?: string;
+  id: string;
+  testClockId?: string;
+}
+type ProviderCustomerMap = Record<string, ProviderCustomer>;
+interface ProviderTestClock {
+  frozenTime: Date;
+  id: string;
+  name?: string | null;
+  status: string;
+}
+interface ProviderInvoice {
+  currency: string;
+  hostedUrl?: string | null;
+  periodEndAt?: Date | null;
+  periodStartAt?: Date | null;
+  providerInvoiceId: string;
+  status: string | null;
+  totalAmount: number;
+}
+interface ProviderRequiredAction {
+  clientSecret?: string;
+  paymentIntentId?: string;
+  type: string;
+}
+interface ProviderSubscription {
+  cancelAtPeriodEnd: boolean;
+  canceledAt?: Date | null;
+  currentPeriodEndAt?: Date | null;
+  currentPeriodStartAt?: Date | null;
+  endedAt?: Date | null;
+  providerPriceId?: string | null;
+  providerSubscriptionId: string;
+  providerSubscriptionScheduleId?: string | null;
+  status: string;
+}
+interface ProviderSubscriptionResult {
+  invoice?: ProviderInvoice | null;
+  paymentUrl: string | null;
+  providerCheckoutSessionId?: string;
+  requiredAction?: ProviderRequiredAction | null;
+  subscription?: ProviderSubscription | null;
+}
+interface StripeRuntime {
+  upsertCustomer(data: {
+    createTestClock?: boolean;
+    id: string;
+    email?: string;
+    name?: string;
+    metadata?: Record<string, string>;
+  }): Promise<{
+    providerCustomer: ProviderCustomer;
+  }>;
+  deleteCustomer(data: {
+    providerCustomerId: string;
+  }): Promise<void>;
+  getTestClock(data: {
+    testClockId: string;
+  }): Promise<ProviderTestClock>;
+  advanceTestClock(data: {
+    testClockId: string;
+    frozenTime: Date;
+  }): Promise<ProviderTestClock>;
+  attachPaymentMethod(data: {
+    providerCustomerId: string;
+    returnURL: string;
+  }): Promise<{
+    url: string;
+  }>;
+  createSubscriptionCheckout(data: {
+    providerCustomerId: string;
+    providerPriceId: string;
+    successUrl: string;
+    cancelUrl?: string;
+    metadata?: Record<string, string>;
+  }): Promise<{
+    paymentUrl: string;
+    providerCheckoutSessionId: string;
+  }>;
+  createSubscription(data: {
+    providerCustomerId: string;
+    providerPriceId: string;
+  }): Promise<ProviderSubscriptionResult>;
+  updateSubscription(data: {
+    providerPriceId: string;
+    providerSubscriptionId: string;
+  }): Promise<ProviderSubscriptionResult>;
+  createInvoice(data: {
+    providerCustomerId: string;
+    lines: Array<{
+      amount: number;
+      description: string;
+    }>;
+    autoAdvance?: boolean;
+  }): Promise<ProviderInvoice>;
+  scheduleSubscriptionChange(data: {
+    providerPriceId?: string | null;
+    providerSubscriptionScheduleId?: string | null;
+    providerSubscriptionId: string;
+  }): Promise<ProviderSubscriptionResult>;
+  cancelSubscription(data: {
+    currentPeriodEndAt?: Date | null;
+    providerSubscriptionId: string;
+    providerSubscriptionScheduleId?: string | null;
+  }): Promise<ProviderSubscriptionResult>;
+  listActiveSubscriptions(data: {
+    providerCustomerId: string;
+  }): Promise<Array<{
+    providerSubscriptionId: string;
+  }>>;
+  resumeSubscription(data: {
+    providerSubscriptionId: string;
+    providerSubscriptionScheduleId?: string | null;
+  }): Promise<ProviderSubscriptionResult>;
+  detachPaymentMethod(data: {
+    providerMethodId: string;
+  }): Promise<void>;
+  syncProduct(data: {
+    id: string;
+    name: string;
+    priceAmount: number;
+    priceInterval?: string | null;
+    existingProviderProductId?: string | null;
+    existingProviderPriceId?: string | null;
+  }): Promise<{
+    providerProductId: string;
+    providerPriceId: string;
+  }>;
+  handleWebhook(data: {
+    body: string;
+    headers: Record<string, string>;
+  }): Promise<NormalizedWebhookEvent[]>;
+  createPortalSession(data: {
+    providerCustomerId: string;
+    returnUrl: string;
+  }): Promise<{
+    url: string;
+  }>;
+}
+interface StripeProviderOptions {
+  currency?: string;
+  secretKey: string;
+  webhookSecret: string;
+}
+interface StripeProviderConfig extends StripeProviderOptions {
+  id: string;
+  kind: "stripe";
+  /**
+   * Internal test hook so repo tests can stub the Stripe runtime without a network client.
+   */
+  runtime?: StripeRuntime;
+}
+type PayKitProvider = StripeProviderConfig;
+//#endregion
+export { PayKitProvider, ProviderCustomer, ProviderCustomerMap, ProviderTestClock, StripeProviderConfig, StripeProviderOptions, StripeRuntime };