@farm.js/stripe 0.1.0-beta.0

package/dist/storage.js

@@ -0,0 +1,645 @@
+function requireOrmModel(options) {
+    const modelClient = options.orm?.[options.model];
+    if (!modelClient || typeof modelClient !== "object") {
+        throw new Error(`Stripe ORM storage adapter could not find orm.${options.model}.`);
+    }
+    const candidate = modelClient;
+    if (typeof candidate.findFirst !== "function" ||
+        typeof candidate.create !== "function" ||
+        typeof candidate.update !== "function") {
+        throw new Error(`Stripe ORM storage adapter expected orm.${options.model} to expose findFirst, create, and update.`);
+    }
+    return candidate;
+}
+function createBillingSnapshotData(snapshot) {
+    return {
+        ownerId: snapshot.owner.id,
+        ownerKind: snapshot.owner.kind,
+        stripeCustomerId: snapshot.stripeCustomerId,
+        stripeSubscriptionId: snapshot.stripeSubscriptionId,
+        planId: snapshot.planId,
+        productId: snapshot.productId,
+        status: snapshot.status,
+        currentPeriodEnd: snapshot.currentPeriodEnd,
+        cancelAtPeriodEnd: snapshot.cancelAtPeriodEnd,
+        trialEndsAt: snapshot.trialEndsAt,
+        trialUsedAt: snapshot.trialUsedAt,
+        seatQuantity: snapshot.seatQuantity,
+        seatAllowanceOverride: snapshot.seatAllowanceOverride,
+        updatedAt: new Date(),
+    };
+}
+function isUnknownPrismaFieldError(error, field) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const normalizedMessage = error.message.replace(/\s+/g, " ");
+    return normalizedMessage.includes(`Unknown argument \`${field}\``);
+}
+async function withPrismaDataFieldsFallback(operation, data, fallbackFields) {
+    let nextData = { ...data };
+    for (const field of fallbackFields) {
+        try {
+            return await operation(nextData);
+        }
+        catch (error) {
+            if (!isUnknownPrismaFieldError(error, field)) {
+                throw error;
+            }
+            delete nextData[field];
+        }
+    }
+    return await operation(nextData);
+}
+function createBillingRecordId() {
+    const randomUuid = globalThis.crypto?.randomUUID?.();
+    if (randomUuid) {
+        return randomUuid;
+    }
+    return `farm-billing-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function getRecordValue(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function getNullableString(record, ...keys) {
+    const value = getRecordValue(record, ...keys);
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getNullableInteger(record, ...keys) {
+    const value = getRecordValue(record, ...keys);
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isInteger(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function getBooleanValue(record, ...keys) {
+    const value = getRecordValue(record, ...keys);
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    return Boolean(value);
+}
+function toSnapshot(record) {
+    return {
+        owner: {
+            kind: getRecordValue(record, "ownerKind", "owner_kind") === "organization"
+                ? "organization"
+                : "user",
+            id: String(getRecordValue(record, "ownerId", "owner_id") ?? ""),
+        },
+        planId: String(getRecordValue(record, "planId", "plan_id") ?? "free"),
+        productId: getNullableString(record, "productId", "product_id"),
+        status: normalizeStatus(getRecordValue(record, "status")),
+        stripeCustomerId: getNullableString(record, "stripeCustomerId", "stripe_customer_id"),
+        stripeSubscriptionId: getNullableString(record, "stripeSubscriptionId", "stripe_subscription_id"),
+        currentPeriodEnd: getRecordValue(record, "currentPeriodEnd", "current_period_end") instanceof Date
+            ? getRecordValue(record, "currentPeriodEnd", "current_period_end")
+            : typeof getRecordValue(record, "currentPeriodEnd", "current_period_end") === "string"
+                ? new Date(String(getRecordValue(record, "currentPeriodEnd", "current_period_end")))
+                : null,
+        cancelAtPeriodEnd: getBooleanValue(record, "cancelAtPeriodEnd", "cancel_at_period_end"),
+        trialEndsAt: getRecordValue(record, "trialEndsAt", "trial_ends_at") instanceof Date
+            ? getRecordValue(record, "trialEndsAt", "trial_ends_at")
+            : typeof getRecordValue(record, "trialEndsAt", "trial_ends_at") === "string"
+                ? new Date(String(getRecordValue(record, "trialEndsAt", "trial_ends_at")))
+                : null,
+        trialUsedAt: getRecordValue(record, "trialUsedAt", "trial_used_at") instanceof Date
+            ? getRecordValue(record, "trialUsedAt", "trial_used_at")
+            : typeof getRecordValue(record, "trialUsedAt", "trial_used_at") === "string"
+                ? new Date(String(getRecordValue(record, "trialUsedAt", "trial_used_at")))
+                : null,
+        seatQuantity: getNullableInteger(record, "seatQuantity", "seat_quantity"),
+        seatAllowanceOverride: getNullableInteger(record, "seatAllowanceOverride", "seat_allowance_override"),
+    };
+}
+function normalizeStatus(value) {
+    switch (value) {
+        case "trialing":
+        case "active":
+        case "past_due":
+        case "canceled":
+        case "unpaid":
+        case "incomplete":
+            return value;
+        default:
+            return "free";
+    }
+}
+function requirePrismaDelegate(options) {
+    const modelName = options.model ?? "billingBillingAccount";
+    const delegate = options.prisma?.[modelName];
+    if (!delegate || typeof delegate !== "object") {
+        throw new Error(`Stripe Prisma storage adapter could not find prisma.${modelName}.`);
+    }
+    return delegate;
+}
+export function prismaStorageAdapter(options) {
+    const delegate = requirePrismaDelegate(options);
+    async function findByOwner(owner) {
+        return await delegate.findFirst({
+            where: {
+                ownerKind: owner.kind,
+                ownerId: owner.id,
+            },
+        });
+    }
+    async function findByCustomerId(customerId) {
+        return await delegate.findFirst({
+            where: {
+                stripeCustomerId: customerId,
+            },
+        });
+    }
+    return {
+        async getBillingAccount(owner) {
+            const record = await findByOwner(owner);
+            return record ? toSnapshot(record) : null;
+        },
+        async getBillingAccountByStripeCustomerId(customerId) {
+            const record = await findByCustomerId(customerId);
+            return record ? toSnapshot(record) : null;
+        },
+        async ensureCustomer({ owner, stripe }) {
+            const existing = await findByOwner(owner);
+            if (typeof existing?.stripeCustomerId === "string" && existing.stripeCustomerId) {
+                return {
+                    customerId: existing.stripeCustomerId,
+                };
+            }
+            const customer = await stripe.customers.create({
+                email: owner.email,
+                metadata: {
+                    ownerId: owner.id,
+                    ownerKind: owner.kind,
+                },
+            });
+            if (existing?.id) {
+                await delegate.update({
+                    where: { id: existing.id },
+                    data: {
+                        stripeCustomerId: customer.id,
+                    },
+                });
+            }
+            else {
+                await withPrismaDataFieldsFallback((data) => delegate.create({
+                    data,
+                }), {
+                    ownerId: owner.id,
+                    ownerKind: owner.kind,
+                    stripeCustomerId: customer.id,
+                    planId: "free",
+                    productId: null,
+                    status: "free",
+                    cancelAtPeriodEnd: false,
+                    trialEndsAt: null,
+                    trialUsedAt: null,
+                    seatQuantity: null,
+                    seatAllowanceOverride: null,
+                }, ["seatAllowanceOverride", "seatQuantity", "trialUsedAt", "trialEndsAt", "productId"]);
+            }
+            return {
+                customerId: customer.id,
+            };
+        },
+        async saveBillingSnapshot(snapshot) {
+            const existing = await findByOwner(snapshot.owner);
+            const data = {
+                ownerId: snapshot.owner.id,
+                ownerKind: snapshot.owner.kind,
+                stripeCustomerId: snapshot.stripeCustomerId,
+                stripeSubscriptionId: snapshot.stripeSubscriptionId,
+                planId: snapshot.planId,
+                productId: snapshot.productId,
+                status: snapshot.status,
+                currentPeriodEnd: snapshot.currentPeriodEnd,
+                cancelAtPeriodEnd: snapshot.cancelAtPeriodEnd,
+                trialEndsAt: snapshot.trialEndsAt,
+                trialUsedAt: snapshot.trialUsedAt,
+                seatQuantity: snapshot.seatQuantity,
+                seatAllowanceOverride: snapshot.seatAllowanceOverride,
+            };
+            if (existing?.id) {
+                await withPrismaDataFieldsFallback((retryData) => delegate.update({
+                    where: { id: existing.id },
+                    data: retryData,
+                }), data, ["seatAllowanceOverride", "seatQuantity", "trialUsedAt", "trialEndsAt", "productId"]);
+                return;
+            }
+            await withPrismaDataFieldsFallback((retryData) => delegate.create({
+                data: retryData,
+            }), data, ["seatAllowanceOverride", "seatQuantity", "trialUsedAt", "trialEndsAt", "productId"]);
+        },
+        async clearBillingSnapshot(owner) {
+            const existing = await findByOwner(owner);
+            if (!existing?.id) {
+                return;
+            }
+            await withPrismaDataFieldsFallback((data) => delegate.update({
+                where: { id: existing.id },
+                data,
+            }), {
+                planId: "free",
+                productId: null,
+                status: "free",
+                stripeSubscriptionId: null,
+                currentPeriodEnd: null,
+                cancelAtPeriodEnd: false,
+                trialEndsAt: null,
+                seatQuantity: null,
+            }, ["seatQuantity", "trialEndsAt", "productId"]);
+        },
+    };
+}
+export function ormStorageAdapter(options) {
+    const modelName = options.model ?? "billingAccount";
+    let modelPromise;
+    async function getModel() {
+        modelPromise ??= Promise.resolve(typeof options.orm === "function" ? options.orm() : options.orm).then((orm) => requireOrmModel({
+            orm,
+            model: modelName,
+        }));
+        return modelPromise;
+    }
+    async function findByOwner(owner) {
+        const model = await getModel();
+        return await model.findFirst({
+            where: {
+                ownerKind: owner.kind,
+                ownerId: owner.id,
+            },
+        });
+    }
+    async function findByCustomerId(customerId) {
+        const model = await getModel();
+        return await model.findFirst({
+            where: {
+                stripeCustomerId: customerId,
+            },
+        });
+    }
+    return {
+        async getBillingAccount(owner) {
+            const record = await findByOwner(owner);
+            return record ? toSnapshot(record) : null;
+        },
+        async getBillingAccountByStripeCustomerId(customerId) {
+            const record = await findByCustomerId(customerId);
+            return record ? toSnapshot(record) : null;
+        },
+        async ensureCustomer({ owner, stripe }) {
+            const existing = await findByOwner(owner);
+            const existingCustomerId = existing && getNullableString(existing, "stripeCustomerId", "stripe_customer_id");
+            if (existingCustomerId) {
+                return {
+                    customerId: existingCustomerId,
+                };
+            }
+            const customer = await stripe.customers.create({
+                email: owner.email,
+                metadata: {
+                    ownerId: owner.id,
+                    ownerKind: owner.kind,
+                },
+            });
+            const model = await getModel();
+            if (existing?.id) {
+                await model.update({
+                    where: {
+                        id: existing.id,
+                    },
+                    data: {
+                        stripeCustomerId: customer.id,
+                        updatedAt: new Date(),
+                    },
+                });
+            }
+            else {
+                await model.create({
+                    data: {
+                        id: createBillingRecordId(),
+                        ownerId: owner.id,
+                        ownerKind: owner.kind,
+                        stripeCustomerId: customer.id,
+                        stripeSubscriptionId: null,
+                        planId: "free",
+                        productId: null,
+                        status: "free",
+                        currentPeriodEnd: null,
+                        cancelAtPeriodEnd: false,
+                        trialEndsAt: null,
+                        trialUsedAt: null,
+                        seatQuantity: null,
+                        seatAllowanceOverride: null,
+                        createdAt: new Date(),
+                        updatedAt: new Date(),
+                    },
+                });
+            }
+            return {
+                customerId: customer.id,
+            };
+        },
+        async saveBillingSnapshot(snapshot) {
+            const existing = await findByOwner(snapshot.owner);
+            const data = createBillingSnapshotData(snapshot);
+            const model = await getModel();
+            if (existing?.id) {
+                await model.update({
+                    where: {
+                        id: existing.id,
+                    },
+                    data,
+                });
+                return;
+            }
+            await model.create({
+                data: {
+                    id: createBillingRecordId(),
+                    ...data,
+                    createdAt: new Date(),
+                },
+            });
+        },
+        async clearBillingSnapshot(owner) {
+            const existing = await findByOwner(owner);
+            if (!existing?.id) {
+                return;
+            }
+            const model = await getModel();
+            await model.update({
+                where: {
+                    id: existing.id,
+                },
+                data: {
+                    planId: "free",
+                    productId: null,
+                    status: "free",
+                    stripeSubscriptionId: null,
+                    currentPeriodEnd: null,
+                    cancelAtPeriodEnd: false,
+                    trialEndsAt: null,
+                    seatQuantity: null,
+                    updatedAt: new Date(),
+                },
+            });
+        },
+    };
+}
+export function sqliteStorageAdapter(options) {
+    const tableName = options.tableName ?? "billing_account";
+    const db = options.db;
+    const tableInfoStatement = db.prepare(`PRAGMA table_info("${tableName}")`);
+    const supportedColumns = typeof tableInfoStatement.all === "function"
+        ? new Set(tableInfoStatement.all().map((row) => String(row.name ?? "")))
+        : null;
+    const hasColumn = (columnName) => supportedColumns ? supportedColumns.has(columnName) : true;
+    const supportsTrialColumns = hasColumn("trial_ends_at") && hasColumn("trial_used_at");
+    const supportsSeatQuantityColumn = hasColumn("seat_quantity");
+    const supportsSeatAllowanceOverrideColumn = hasColumn("seat_allowance_override");
+    const selectByOwner = db.prepare(`SELECT * FROM "${tableName}" WHERE owner_kind = ? AND owner_id = ? LIMIT 1`);
+    const selectByCustomerId = db.prepare(`SELECT * FROM "${tableName}" WHERE stripe_customer_id = ? LIMIT 1`);
+    const insertRecord = db.prepare(`INSERT INTO "${tableName}" (
+      id,
+      owner_id,
+      owner_kind,
+      stripe_customer_id,
+      stripe_subscription_id,
+      plan_id,
+      product_id,
+      status,
+      current_period_end,
+      cancel_at_period_end,
+      ${supportsTrialColumns ? "trial_ends_at," : ""}
+      ${supportsTrialColumns ? "trial_used_at," : ""}
+      ${supportsSeatQuantityColumn ? "seat_quantity," : ""}
+      ${supportsSeatAllowanceOverrideColumn ? "seat_allowance_override," : ""}
+      created_at,
+      updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ${supportsTrialColumns ? "?, ?, " : ""}${supportsSeatQuantityColumn ? "?, " : ""}${supportsSeatAllowanceOverrideColumn ? "?, " : ""}CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`);
+    const updateByOwner = db.prepare(`UPDATE "${tableName}" SET
+      stripe_customer_id = ?,
+      stripe_subscription_id = ?,
+      plan_id = ?,
+      product_id = ?,
+      status = ?,
+      current_period_end = ?,
+      cancel_at_period_end = ?,
+      ${supportsTrialColumns ? "trial_ends_at = ?, trial_used_at = ?," : ""}
+      ${supportsSeatQuantityColumn ? "seat_quantity = ?," : ""}
+      ${supportsSeatAllowanceOverrideColumn ? "seat_allowance_override = ?," : ""}
+      updated_at = CURRENT_TIMESTAMP
+    WHERE owner_kind = ? AND owner_id = ?`);
+    const clearByOwner = db.prepare(`UPDATE "${tableName}" SET
+      plan_id = 'free',
+      product_id = NULL,
+      status = 'free',
+      stripe_subscription_id = NULL,
+      current_period_end = NULL,
+      cancel_at_period_end = 0,
+      ${supportsTrialColumns ? "trial_ends_at = NULL," : ""}
+      ${supportsSeatQuantityColumn ? "seat_quantity = NULL," : ""}
+      updated_at = CURRENT_TIMESTAMP
+    WHERE owner_kind = ? AND owner_id = ?`);
+    const updateCustomerByOwner = db.prepare(`UPDATE "${tableName}" SET
+      stripe_customer_id = ?,
+      updated_at = CURRENT_TIMESTAMP
+    WHERE owner_kind = ? AND owner_id = ?`);
+    function readByOwner(owner) {
+        return selectByOwner.get(owner.kind, owner.id) ?? null;
+    }
+    return {
+        async getBillingAccount(owner) {
+            const record = readByOwner(owner);
+            return record ? toSnapshot(record) : null;
+        },
+        async getBillingAccountByStripeCustomerId(customerId) {
+            const record = selectByCustomerId.get(customerId) ?? null;
+            return record ? toSnapshot(record) : null;
+        },
+        async ensureCustomer({ owner, stripe }) {
+            const existing = readByOwner(owner);
+            const existingCustomerId = existing && getNullableString(existing, "stripeCustomerId", "stripe_customer_id");
+            if (existingCustomerId) {
+                return {
+                    customerId: existingCustomerId,
+                };
+            }
+            const customer = await stripe.customers.create({
+                email: owner.email,
+                metadata: {
+                    ownerId: owner.id,
+                    ownerKind: owner.kind,
+                },
+            });
+            if (existing) {
+                updateCustomerByOwner.run(customer.id, owner.kind, owner.id);
+            }
+            else {
+                insertRecord.run(createBillingRecordId(), owner.id, owner.kind, customer.id, null, "free", null, "free", null, 0, ...(supportsTrialColumns ? [null, null] : []), ...(supportsSeatQuantityColumn ? [null] : []), ...(supportsSeatAllowanceOverrideColumn ? [null] : []));
+            }
+            return {
+                customerId: customer.id,
+            };
+        },
+        async saveBillingSnapshot(snapshot) {
+            const existing = readByOwner(snapshot.owner);
+            const periodEnd = snapshot.currentPeriodEnd ? snapshot.currentPeriodEnd.toISOString() : null;
+            const trialEndsAt = snapshot.trialEndsAt ? snapshot.trialEndsAt.toISOString() : null;
+            const trialUsedAt = snapshot.trialUsedAt ? snapshot.trialUsedAt.toISOString() : null;
+            const seatQuantity = snapshot.seatQuantity;
+            const seatAllowanceOverride = snapshot.seatAllowanceOverride;
+            if (existing) {
+                updateByOwner.run(snapshot.stripeCustomerId, snapshot.stripeSubscriptionId, snapshot.planId, snapshot.productId, snapshot.status, periodEnd, snapshot.cancelAtPeriodEnd ? 1 : 0, ...(supportsTrialColumns ? [trialEndsAt, trialUsedAt] : []), ...(supportsSeatQuantityColumn ? [seatQuantity] : []), ...(supportsSeatAllowanceOverrideColumn ? [seatAllowanceOverride] : []), snapshot.owner.kind, snapshot.owner.id);
+                return;
+            }
+            insertRecord.run(createBillingRecordId(), snapshot.owner.id, snapshot.owner.kind, snapshot.stripeCustomerId, snapshot.stripeSubscriptionId, snapshot.planId, snapshot.productId, snapshot.status, periodEnd, snapshot.cancelAtPeriodEnd ? 1 : 0, ...(supportsTrialColumns ? [trialEndsAt, trialUsedAt] : []), ...(supportsSeatQuantityColumn ? [seatQuantity] : []), ...(supportsSeatAllowanceOverrideColumn ? [seatAllowanceOverride] : []));
+        },
+        async clearBillingSnapshot(owner) {
+            const existing = readByOwner(owner);
+            if (!existing) {
+                return;
+            }
+            clearByOwner.run(owner.kind, owner.id);
+        },
+    };
+}
+function drizzleHasColumn(table, key) {
+    return key in table;
+}
+export function drizzleStorageAdapter(options) {
+    const { db, table, eq, and } = options;
+    async function firstByOwner(owner) {
+        const rows = await db
+            .select()
+            .from(table)
+            .where(and(eq(table.ownerKind, owner.kind), eq(table.ownerId, owner.id)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async function firstByCustomerId(customerId) {
+        const rows = await db
+            .select()
+            .from(table)
+            .where(eq(table.stripeCustomerId, customerId))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    return {
+        async getBillingAccount(owner) {
+            const record = await firstByOwner(owner);
+            return record ? toSnapshot(record) : null;
+        },
+        async getBillingAccountByStripeCustomerId(customerId) {
+            const record = await firstByCustomerId(customerId);
+            return record ? toSnapshot(record) : null;
+        },
+        async ensureCustomer({ owner, stripe }) {
+            const existing = await firstByOwner(owner);
+            if (typeof existing?.stripeCustomerId === "string" && existing.stripeCustomerId) {
+                return {
+                    customerId: existing.stripeCustomerId,
+                };
+            }
+            const customer = await stripe.customers.create({
+                email: owner.email,
+                metadata: {
+                    ownerId: owner.id,
+                    ownerKind: owner.kind,
+                },
+            });
+            if (existing?.id != null) {
+                await db
+                    .update(table)
+                    .set({
+                    stripeCustomerId: customer.id,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(table.id, existing.id));
+            }
+            else {
+                await db.insert(table).values({
+                    ownerId: owner.id,
+                    ownerKind: owner.kind,
+                    stripeCustomerId: customer.id,
+                    planId: "free",
+                    productId: null,
+                    status: "free",
+                    cancelAtPeriodEnd: false,
+                    ...(drizzleHasColumn(table, "trialEndsAt") ? { trialEndsAt: null } : {}),
+                    ...(drizzleHasColumn(table, "trialUsedAt") ? { trialUsedAt: null } : {}),
+                    ...(drizzleHasColumn(table, "seatQuantity") ? { seatQuantity: null } : {}),
+                    ...(drizzleHasColumn(table, "seatAllowanceOverride")
+                        ? { seatAllowanceOverride: null }
+                        : {}),
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                });
+            }
+            return {
+                customerId: customer.id,
+            };
+        },
+        async saveBillingSnapshot(snapshot) {
+            const existing = await firstByOwner(snapshot.owner);
+            const data = {
+                ownerId: snapshot.owner.id,
+                ownerKind: snapshot.owner.kind,
+                stripeCustomerId: snapshot.stripeCustomerId,
+                stripeSubscriptionId: snapshot.stripeSubscriptionId,
+                planId: snapshot.planId,
+                productId: snapshot.productId,
+                status: snapshot.status,
+                currentPeriodEnd: snapshot.currentPeriodEnd,
+                cancelAtPeriodEnd: snapshot.cancelAtPeriodEnd,
+                ...(drizzleHasColumn(table, "trialEndsAt") ? { trialEndsAt: snapshot.trialEndsAt } : {}),
+                ...(drizzleHasColumn(table, "trialUsedAt") ? { trialUsedAt: snapshot.trialUsedAt } : {}),
+                ...(drizzleHasColumn(table, "seatQuantity") ? { seatQuantity: snapshot.seatQuantity } : {}),
+                ...(drizzleHasColumn(table, "seatAllowanceOverride")
+                    ? { seatAllowanceOverride: snapshot.seatAllowanceOverride }
+                    : {}),
+                updatedAt: new Date(),
+            };
+            if (existing?.id != null) {
+                await db.update(table).set(data).where(eq(table.id, existing.id));
+                return;
+            }
+            await db.insert(table).values({
+                ...data,
+                createdAt: new Date(),
+            });
+        },
+        async clearBillingSnapshot(owner) {
+            const existing = await firstByOwner(owner);
+            if (existing?.id == null) {
+                return;
+            }
+            await db
+                .update(table)
+                .set({
+                planId: "free",
+                productId: null,
+                status: "free",
+                stripeSubscriptionId: null,
+                currentPeriodEnd: null,
+                cancelAtPeriodEnd: false,
+                ...(drizzleHasColumn(table, "trialEndsAt") ? { trialEndsAt: null } : {}),
+                ...(drizzleHasColumn(table, "seatQuantity") ? { seatQuantity: null } : {}),
+                updatedAt: new Date(),
+            })
+                .where(eq(table.id, existing.id));
+        },
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@farm.js/stripe",
+  "version": "0.1.0-beta.0",
+  "description": "Stripe billing integration for Farm.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/farming-labs/farm.js",
+    "directory": "packages/farm-stripe"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./storage": {
+      "types": "./dist/storage.d.ts",
+      "import": "./dist/storage.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "stripe": "^20.4.1",
+    "@farm.js/integration-utils": "0.1.0-beta.0",
+    "@farm.js/core": "0.1.0-beta.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "test": "echo 'No tests in this package'"
+  }
+}