sparta_worlds 0.6.0

package/dist/cli/import.js

@@ -0,0 +1,530 @@
+import { createHash } from "node:crypto";
+export const SEED_FIELDS = {
+    customers: ["id", "name", "email", "balance", "created_offset", "metadata"],
+    products: ["id", "name", "active"],
+    prices: ["id", "product", "unit_amount", "currency", "nickname", "active", "recurring"],
+    invoices: ["id", "customer", "currency", "status", "created_offset", "lines", "charges"],
+    lines: ["description", "amount", "quantity", "price"],
+    charges: ["id", "amount", "amount_refunded"],
+    subscriptions: [
+        "id",
+        "customer",
+        "price",
+        "quantity",
+        "cancel_at_period_end",
+        "created_offset",
+        "current_period_start",
+        "current_period_end",
+    ],
+};
+export const PSEUDONYMIZATION_NOTE = "Identities are replaced by deterministic fakes and ids are hashed and remapped: pseudonymization, not anonymity. Amounts, cadence and timing survive and can identify an account on their own; free text is replaced unless a --keep-* flag says otherwise. Product and price ids are copied verbatim because agent code references them; a merchant-chosen product or price id is free text and is listed under verbatim.";
+export function identityMapDoc(seedName, seedHashValue, identities) {
+    return { version: 1, seed: seedName, seed_hash: seedHashValue, customers: identities };
+}
+const FIRST = [
+    "Avery",
+    "Blair",
+    "Casey",
+    "Devon",
+    "Ellis",
+    "Frankie",
+    "Gray",
+    "Harper",
+    "Indigo",
+    "Jules",
+    "Kai",
+    "Lane",
+    "Marlowe",
+    "Noa",
+    "Oakley",
+    "Parker",
+    "Quinn",
+    "Reese",
+    "Sage",
+    "Tatum",
+    "Umber",
+    "Vale",
+    "Wren",
+    "Xen",
+    "Yael",
+    "Zephyr",
+];
+const LAST = [
+    "Ashford",
+    "Birch",
+    "Calder",
+    "Dunmore",
+    "Eastwood",
+    "Fenwick",
+    "Garland",
+    "Hollis",
+    "Ingram",
+    "Jasper",
+    "Kessler",
+    "Lockhart",
+    "Merritt",
+    "Northway",
+    "Oakes",
+    "Pemberton",
+    "Quill",
+    "Rutledge",
+    "Sterling",
+    "Thorne",
+    "Underhill",
+    "Vance",
+    "Whitfield",
+    "Xanders",
+    "York",
+    "Zale",
+];
+const B62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function digest(input) {
+    return createHash("sha256").update(`worlds-import:${input}`).digest();
+}
+function remapId(prefix, originalId) {
+    const d = digest(originalId);
+    let out = "";
+    for (let i = 0; i < 11; i++)
+        out += B62[d[i] % 62];
+    return `${prefix}_imp${out}`;
+}
+function fakeIdentity(originalId) {
+    const d = digest(`identity:${originalId}`);
+    const first = FIRST[d[0] % FIRST.length];
+    const last = LAST[d[1] % LAST.length];
+    let tag = "";
+    for (let i = 2; i < 6; i++)
+        tag += B62[d[i] % 62].toLowerCase();
+    return { name: `${first} ${last}`, email: `${first.toLowerCase()}.${last.toLowerCase()}.${tag}@example.com` };
+}
+function tag(input) {
+    const d = digest(`label:${input}`);
+    let out = "";
+    for (let i = 0; i < 4; i++)
+        out += B62[d[i] % 62];
+    return out;
+}
+const fakeProductName = (productId) => `Product ${tag(productId)}`;
+const fakePriceNickname = (price) => `${price.recurring ? "Plan" : "Item"} ${tag(String(price.id))}`;
+const GENERATED_ID_LENGTH = { prod: 14, price: 24 };
+const isGeneratedId = (prefix, id) => new RegExp(`^${prefix}_[A-Za-z0-9]{${GENERATED_ID_LENGTH[prefix]}}$`).test(id);
+const hasMetadata = (o) => o.metadata !== null && typeof o.metadata === "object" && Object.keys(o.metadata).length > 0;
+async function stripeGet(opts, path, params = {}) {
+    const qs = new URLSearchParams(params).toString();
+    const res = await fetch(`${opts.baseUrl}${path}${qs ? `?${qs}` : ""}`, {
+        headers: { authorization: `Bearer ${opts.apiKey}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        let message = text;
+        try {
+            message = JSON.parse(text).error?.message ?? text;
+        }
+        catch {
+        }
+        throw new Error(`GET ${path} → ${res.status}: ${message}`);
+    }
+    return JSON.parse(text);
+}
+async function listAll(opts, path, max, params = {}) {
+    const out = [];
+    let startingAfter;
+    while (out.length < max) {
+        const page = await stripeGet(opts, path, {
+            ...params,
+            limit: String(Math.min(100, max - out.length)),
+            ...(startingAfter ? { starting_after: startingAfter } : {}),
+        });
+        const data = page.data ?? [];
+        out.push(...data);
+        if (!page.has_more || data.length === 0)
+            break;
+        startingAfter = String(data[data.length - 1].id);
+    }
+    return out;
+}
+const num = (v, fallback = 0) => (typeof v === "number" ? v : fallback);
+const str = (v) => (typeof v === "string" ? v : undefined);
+export async function importStripeSeed(opts) {
+    const skipped = [];
+    const products = await listAll(opts, "/v1/products", opts.limit);
+    const prices = await listAll(opts, "/v1/prices", opts.limit);
+    const customers = (await listAll(opts, "/v1/customers", opts.limit)).filter((c) => c.deleted !== true);
+    const invoices = await listAll(opts, "/v1/invoices", opts.limit);
+    const charges = await listAll(opts, "/v1/charges", opts.limit);
+    const subscriptions = await listAll(opts, "/v1/subscriptions", opts.limit, { status: "active" });
+    const priceById = new Map(prices.map((p) => [String(p.id), p]));
+    const productIds = new Set(products.map((p) => String(p.id)));
+    const customerIds = new Set(customers.map((c) => String(c.id)));
+    const named = { emails: 0, found: 0, missing: [] };
+    if (opts.customerEmails !== undefined && opts.customerEmails.length > 0) {
+        const invoiceIds = new Set(invoices.map((i) => String(i.id)));
+        const chargeIds = new Set(charges.map((c) => String(c.id)));
+        const subscriptionIds = new Set(subscriptions.map((s) => String(s.id)));
+        const seen = new Set();
+        const live = (list) => list.filter((c) => c.deleted !== true);
+        for (const raw of opts.customerEmails) {
+            const email = raw.trim();
+            const key = email.toLowerCase();
+            if (email === "" || seen.has(key))
+                continue;
+            seen.add(key);
+            named.emails++;
+            let found = live(await listAll(opts, "/v1/customers", 100, { email }));
+            if (found.length === 0 && key !== email)
+                found = live(await listAll(opts, "/v1/customers", 100, { email: key }));
+            if (found.length === 0) {
+                named.missing.push(email);
+                continue;
+            }
+            named.found++;
+            for (const c of found) {
+                const id = String(c.id);
+                if (!customerIds.has(id)) {
+                    customers.push(c);
+                    customerIds.add(id);
+                }
+                for (const inv of await listAll(opts, "/v1/invoices", opts.limit, { customer: id }))
+                    if (!invoiceIds.has(String(inv.id))) {
+                        invoices.push(inv);
+                        invoiceIds.add(String(inv.id));
+                    }
+                for (const ch of await listAll(opts, "/v1/charges", opts.limit, { customer: id }))
+                    if (!chargeIds.has(String(ch.id))) {
+                        charges.push(ch);
+                        chargeIds.add(String(ch.id));
+                    }
+                for (const sub of await listAll(opts, "/v1/subscriptions", opts.limit, { customer: id, status: "active" }))
+                    if (!subscriptionIds.has(String(sub.id))) {
+                        subscriptions.push(sub);
+                        subscriptionIds.add(String(sub.id));
+                    }
+            }
+        }
+    }
+    const wantCustomer = async (id) => {
+        if (!id)
+            return false;
+        if (customerIds.has(id))
+            return true;
+        try {
+            const c = await stripeGet(opts, `/v1/customers/${id}`);
+            if (c.deleted === true)
+                return false;
+            customers.push(c);
+            customerIds.add(id);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const wantPrice = async (id) => {
+        if (!id)
+            return undefined;
+        const cached = priceById.get(id);
+        if (cached)
+            return cached;
+        try {
+            const p = await stripeGet(opts, `/v1/prices/${id}`);
+            prices.push(p);
+            priceById.set(id, p);
+            return p;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    for (const sub of subscriptions) {
+        await wantCustomer(str(sub.customer));
+        const item = sub.items?.data?.[0];
+        await wantPrice(str(item?.price?.id));
+    }
+    for (const inv of invoices)
+        await wantCustomer(str(inv.customer));
+    for (const price of prices) {
+        const productId = str(price.product);
+        if (productId && !productIds.has(productId)) {
+            try {
+                products.push(await stripeGet(opts, `/v1/products/${productId}`));
+                productIds.add(productId);
+            }
+            catch {
+                priceById.delete(String(price.id));
+            }
+        }
+    }
+    const allCreated = [...customers, ...products, ...prices, ...invoices, ...charges, ...subscriptions]
+        .map((o) => num(o.created))
+        .filter((n) => n > 0);
+    if (allCreated.length === 0 && opts.epoch === undefined) {
+        throw new Error("nothing to import: the account returned no objects (use --epoch to force an empty seed)");
+    }
+    const epoch = opts.epoch ?? Math.ceil(Math.max(...allCreated) / 86400) * 86400;
+    const offset = (created) => Math.max(0, epoch - num(created, epoch));
+    const chargesByInvoice = new Map();
+    for (const ch of charges) {
+        const invoiceId = str(ch.invoice);
+        if (!invoiceId || ch.status !== "succeeded" || ch.paid !== true)
+            continue;
+        const group = chargesByInvoice.get(invoiceId) ?? [];
+        group.push(ch);
+        chargesByInvoice.set(invoiceId, group);
+    }
+    const keepMetadata = opts.keepMetadata === true;
+    const manifest = {
+        scrub: {
+            replaced: {
+                customer_names: 0,
+                customer_emails: 0,
+                product_names: 0,
+                price_nicknames: 0,
+                line_descriptions: 0,
+                line_descriptions_from_kept_nickname: 0,
+            },
+            dropped: { customer_descriptions: 0, customer_phones: 0, customer_metadata: 0, other_metadata: 0 },
+            retained: {
+                product_names: opts.keepNames === true,
+                price_nicknames: opts.keepNames === true,
+                line_descriptions: opts.keepDescriptions === true,
+                metadata: keepMetadata,
+            },
+            samples: {},
+            verbatim: { product_ids: { count: 0, samples: [] }, price_ids: { count: 0, samples: [] } },
+            allowlist: SEED_FIELDS,
+            note: PSEUDONYMIZATION_NOTE,
+        },
+        lossy: { refunds_folded: 0, disputed_charges: [], notes: [] },
+    };
+    const sample = (kind, text) => {
+        const list = manifest.scrub.samples[kind] ?? [];
+        if (list.length < 3)
+            list.push(text);
+        manifest.scrub.samples[kind] = list;
+    };
+    const verbatimId = (prefix, id) => {
+        if (isGeneratedId(prefix, id))
+            return;
+        const entry = manifest.scrub.verbatim[prefix === "prod" ? "product_ids" : "price_ids"];
+        entry.count++;
+        if (entry.samples.length < 3)
+            entry.samples.push(id);
+    };
+    const dropOtherMetadata = (o) => {
+        if (hasMetadata(o))
+            manifest.scrub.dropped.other_metadata++;
+    };
+    const identities = [];
+    const seedCustomers = customers.map((c) => {
+        const id = String(c.id);
+        const fake = fakeIdentity(id);
+        identities.push({
+            id,
+            email: str(c.email) ?? null,
+            name: str(c.name) ?? null,
+            pseudonym: { id: remapId("cus", id), email: fake.email, name: fake.name },
+        });
+        if (str(c.name))
+            manifest.scrub.replaced.customer_names++;
+        if (str(c.email))
+            manifest.scrub.replaced.customer_emails++;
+        if (str(c.description))
+            manifest.scrub.dropped.customer_descriptions++;
+        if (str(c.phone))
+            manifest.scrub.dropped.customer_phones++;
+        const metadata = hasMetadata(c);
+        if (metadata && !keepMetadata)
+            manifest.scrub.dropped.customer_metadata++;
+        return {
+            id: remapId("cus", id),
+            name: fake.name,
+            email: fake.email,
+            balance: num(c.balance),
+            created_offset: offset(c.created),
+            ...(keepMetadata && metadata ? { metadata: c.metadata } : {}),
+        };
+    });
+    const seedProducts = products.map((p) => {
+        const id = String(p.id);
+        verbatimId("prod", id);
+        dropOtherMetadata(p);
+        const original = str(p.name);
+        let name;
+        if (opts.keepNames && original) {
+            name = original;
+            sample("product_names", original);
+        }
+        else {
+            name = fakeProductName(id);
+            if (original)
+                manifest.scrub.replaced.product_names++;
+        }
+        return { id, name, active: p.active !== false };
+    });
+    const lineDefault = new Map();
+    const keptNickname = new Set();
+    const seedPrices = [...priceById.values()]
+        .filter((p) => productIds.has(String(p.product)))
+        .map((p) => {
+        const id = String(p.id);
+        verbatimId("price", id);
+        dropOtherMetadata(p);
+        const recurring = p.recurring;
+        const original = str(p.nickname);
+        let nickname;
+        if (original && opts.keepNames) {
+            nickname = original;
+            sample("price_nicknames", original);
+            keptNickname.add(id);
+        }
+        else if (original) {
+            nickname = fakePriceNickname(p);
+            manifest.scrub.replaced.price_nicknames++;
+        }
+        lineDefault.set(id, nickname ?? fakePriceNickname(p));
+        return {
+            id,
+            product: String(p.product),
+            unit_amount: num(p.unit_amount),
+            currency: String(p.currency ?? "usd"),
+            ...(nickname ? { nickname } : {}),
+            active: p.active !== false,
+            recurring: recurring
+                ? { interval: String(recurring.interval), interval_count: num(recurring.interval_count, 1) }
+                : null,
+        };
+    });
+    const seedPriceIds = new Set(seedPrices.map((p) => p.id));
+    let chargesAttached = 0;
+    const seedInvoices = [];
+    for (const inv of invoices) {
+        const invoiceId = String(inv.id);
+        const customerId = str(inv.customer);
+        const status = str(inv.status);
+        if (!customerId || !customerIds.has(customerId)) {
+            skipped.push(`invoice ${invoiceId}: customer unavailable`);
+            continue;
+        }
+        if (!status || !["draft", "open", "paid", "void", "uncollectible"].includes(status)) {
+            skipped.push(`invoice ${invoiceId}: unsupported status '${status}'`);
+            continue;
+        }
+        let lines = inv.lines?.data ?? [];
+        if (inv.lines?.has_more) {
+            lines = await listAll(opts, `/v1/invoices/${invoiceId}/lines`, 1000);
+        }
+        if (lines.length === 0) {
+            skipped.push(`invoice ${invoiceId}: no line items`);
+            continue;
+        }
+        dropOtherMetadata(inv);
+        const seedLines = lines.map((line, lidx) => {
+            const priceId = str(line.price?.id);
+            const original = str(line.description);
+            let description;
+            if (opts.keepDescriptions) {
+                description = original ?? null;
+                if (original)
+                    sample("line_descriptions", original);
+            }
+            else {
+                description = (priceId && lineDefault.get(priceId)) || `Line item ${lidx + 1}`;
+                if (priceId && keptNickname.has(priceId))
+                    manifest.scrub.replaced.line_descriptions_from_kept_nickname++;
+                else if (original)
+                    manifest.scrub.replaced.line_descriptions++;
+            }
+            return {
+                description,
+                amount: num(line.amount),
+                quantity: Math.max(1, num(line.quantity, 1)),
+                ...(priceId && seedPriceIds.has(priceId) ? { price: priceId } : {}),
+            };
+        });
+        const invCharges = status === "paid"
+            ? (chargesByInvoice.get(invoiceId) ?? [])
+                .sort((a, b) => num(a.created) - num(b.created))
+                .map((ch) => {
+                const id = remapId("ch", String(ch.id));
+                const refunded = num(ch.amount_refunded);
+                if (refunded > 0)
+                    manifest.lossy.refunds_folded++;
+                if (ch.disputed === true)
+                    manifest.lossy.disputed_charges.push(id);
+                return { id, amount: num(ch.amount), ...(refunded > 0 ? { amount_refunded: refunded } : {}) };
+            })
+            : [];
+        chargesAttached += invCharges.length;
+        seedInvoices.push({
+            id: remapId("in", invoiceId),
+            customer: remapId("cus", customerId),
+            currency: String(inv.currency ?? "usd"),
+            status,
+            created_offset: offset(inv.created),
+            lines: seedLines,
+            ...(invCharges.length > 0 ? { charges: invCharges } : {}),
+        });
+    }
+    const seedSubscriptions = [];
+    for (const sub of subscriptions) {
+        const subId = String(sub.id);
+        const customerId = str(sub.customer);
+        const item = sub.items?.data?.[0];
+        const priceId = str(item?.price?.id);
+        if (!customerId || !customerIds.has(customerId) || !priceId || !seedPriceIds.has(priceId)) {
+            skipped.push(`subscription ${subId}: customer or price unavailable`);
+            continue;
+        }
+        if (!priceById.get(priceId)?.recurring) {
+            skipped.push(`subscription ${subId}: price is not recurring`);
+            continue;
+        }
+        dropOtherMetadata(sub);
+        const periodStart = num(sub.current_period_start, num(item?.current_period_start));
+        const periodEnd = num(sub.current_period_end, num(item?.current_period_end));
+        seedSubscriptions.push({
+            id: remapId("sub", subId),
+            customer: remapId("cus", customerId),
+            price: priceId,
+            quantity: Math.max(1, num(item?.quantity, 1)),
+            cancel_at_period_end: sub.cancel_at_period_end === true,
+            created_offset: offset(sub.created),
+            ...(periodStart > 0 ? { current_period_start: periodStart } : {}),
+            ...(periodEnd > periodStart && periodEnd > 0 ? { current_period_end: periodEnd } : {}),
+        });
+    }
+    const seedDoc = {
+        name: opts.name,
+        version: 1,
+        epoch,
+        clock_mode: "manual",
+        data: {
+            customers: seedCustomers,
+            products: seedProducts,
+            prices: seedPrices,
+            invoices: seedInvoices,
+            subscriptions: seedSubscriptions,
+        },
+    };
+    if (manifest.lossy.refunds_folded > 0) {
+        manifest.lossy.notes.push(`${manifest.lossy.refunds_folded} charge(s) carry prior refunds as amount_refunded; the refund objects themselves are not seedable`);
+    }
+    if (manifest.lossy.disputed_charges.length > 0) {
+        manifest.lossy.notes.push(`${manifest.lossy.disputed_charges.length} disputed charge(s) import as ordinary charges: the twin does not model disputes`);
+    }
+    return {
+        seedDoc,
+        manifest,
+        identities,
+        stats: {
+            customers: seedCustomers.length,
+            products: seedProducts.length,
+            prices: seedPrices.length,
+            invoices: seedInvoices.length,
+            charges_attached: chargesAttached,
+            subscriptions: seedSubscriptions.length,
+            skipped,
+            named,
+        },
+    };
+}