paykitjs 0.1.0-alpha.2

package/dist/cli/utils/format.js

@@ -0,0 +1,58 @@
+import StripeSdk from "stripe";
+import picocolors from "picocolors";
+//#region src/cli/utils/format.ts
+async function getStripeAccountInfo(secretKey) {
+	const mode = stripeMode(secretKey);
+	try {
+		const account = await new StripeSdk(secretKey).accounts.retrieve();
+		return {
+			displayName: account.settings?.dashboard?.display_name || account.business_profile?.name || account.id,
+			mode
+		};
+	} catch {
+		return {
+			displayName: "unknown",
+			mode
+		};
+	}
+}
+function maskConnectionString(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.password) parsed.password = "****";
+		return parsed.toString().replace(/\/$/, "");
+	} catch {
+		return url;
+	}
+}
+function formatPrice(amountCents, interval) {
+	const dollars = amountCents / 100;
+	const formatted = dollars % 1 === 0 ? `$${dollars}` : `$${dollars.toFixed(2)}`;
+	if (!interval) return formatted;
+	if (interval === "month") return `${formatted}/mo`;
+	if (interval === "year") return `${formatted}/yr`;
+	return `${formatted}/${interval}`;
+}
+function stripeMode(secretKey) {
+	return secretKey.startsWith("sk_test_") || secretKey.startsWith("rk_test_") ? "test mode" : "live mode";
+}
+function getConnectionString(pool) {
+	const opts = pool.options;
+	if (opts?.connectionString) return maskConnectionString(opts.connectionString);
+	if (opts?.host) {
+		const user = opts.user ?? "postgres";
+		const port = opts.port ?? 5432;
+		const db = opts.database ?? "postgres";
+		return `postgresql://${user}@${opts.host}:${String(port)}/${db}`;
+	}
+	return "postgresql://localhost:5432/postgres";
+}
+function formatPlanLine(action, name, price) {
+	switch (action) {
+		case "created": return picocolors.green(`  + ${name} (${price})  new`);
+		case "updated": return picocolors.yellow(`  ~ ${name} (${price})  updated`);
+		case "unchanged": return picocolors.dim(`  = ${name} (${price})  unchanged`);
+	}
+}
+//#endregion
+export { formatPlanLine, formatPrice, getConnectionString, getStripeAccountInfo };

package/dist/cli/utils/get-config.js

@@ -0,0 +1,117 @@
+import { isPayKitInstance } from "../../core/create-paykit.js";
+import fs from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { createJiti } from "jiti";
+import * as ts from "typescript";
+//#region src/cli/utils/get-config.ts
+const CONFIG_FILENAMES = [
+	"paykit.ts",
+	"paykit.tsx",
+	"paykit.config.ts",
+	"paykit.config.tsx",
+	"paykit/index.ts",
+	"paykit/index.tsx",
+	"paykit.js",
+	"paykit.jsx",
+	"paykit.config.js",
+	"paykit.config.jsx",
+	"paykit/index.js",
+	"paykit/index.jsx"
+];
+const possiblePayKitConfigPaths = [
+	"",
+	"lib/server",
+	"server/paykit",
+	"server",
+	"paykit",
+	"lib",
+	"src",
+	"src/lib",
+	"src/server",
+	"app"
+].flatMap((dir) => CONFIG_FILENAMES.map((name) => dir ? `${dir}/${name}` : name));
+function resolveReferencePath(configDir, refPath) {
+	const resolvedPath = path.resolve(configDir, refPath);
+	if (refPath.endsWith(".json")) return resolvedPath;
+	if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) return resolvedPath;
+	return path.resolve(configDir, refPath, "tsconfig.json");
+}
+function getPathAliasesRecursive(tsconfigPath, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(tsconfigPath) || !fs.existsSync(tsconfigPath)) return {};
+	visited.add(tsconfigPath);
+	const readResult = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+	if (readResult.error) throw new Error(ts.flattenDiagnosticMessageText(readResult.error.messageText, "\n"));
+	const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, path.dirname(tsconfigPath));
+	const result = {};
+	const paths = parsed.options.paths ?? {};
+	const baseUrl = parsed.options.baseUrl ?? path.dirname(tsconfigPath);
+	for (const [alias, aliasPaths] of Object.entries(paths)) for (const aliasPath of aliasPaths) {
+		const finalAlias = alias.endsWith("*") ? alias.slice(0, -1) : alias;
+		const finalAliasPath = aliasPath.endsWith("*") ? aliasPath.slice(0, -1) : aliasPath;
+		result[finalAlias] = path.resolve(baseUrl, finalAliasPath);
+	}
+	const references = readResult.config.references;
+	if (!references) return result;
+	for (const reference of references) {
+		const referencedAliases = getPathAliasesRecursive(resolveReferencePath(path.dirname(tsconfigPath), reference.path), visited);
+		for (const [alias, aliasPath] of Object.entries(referencedAliases)) result[alias] ??= aliasPath;
+	}
+	return result;
+}
+function getPathAliases(cwd) {
+	const tsconfigPath = path.join(cwd, "tsconfig.json");
+	if (fs.existsSync(tsconfigPath)) return getPathAliasesRecursive(tsconfigPath);
+	const jsconfigPath = path.join(cwd, "jsconfig.json");
+	if (fs.existsSync(jsconfigPath)) return getPathAliasesRecursive(jsconfigPath);
+	return {};
+}
+function loadDotEnv(cwd) {
+	dotenv.config({
+		path: path.join(cwd, ".env"),
+		quiet: true
+	});
+	dotenv.config({
+		override: true,
+		path: path.join(cwd, ".env.local"),
+		quiet: true
+	});
+}
+async function loadModule(cwd, configPath) {
+	loadDotEnv(cwd);
+	return createJiti(configPath, {
+		alias: getPathAliases(cwd),
+		interopDefault: false,
+		jsx: true,
+		moduleCache: false
+	}).import(configPath);
+}
+function getPayKit(moduleValue) {
+	if (!moduleValue || typeof moduleValue !== "object") return null;
+	const moduleObject = moduleValue;
+	return [moduleObject.paykit, moduleObject.default].find((value) => isPayKitInstance(value) || isPayKitLike(value)) ?? null;
+}
+function isPayKitLike(value) {
+	if (!value || typeof value !== "object") return false;
+	const paykit = value;
+	return typeof paykit.handler === "function" && typeof paykit.subscribe === "function" && typeof paykit.handleWebhook === "function" && "options" in paykit;
+}
+async function getPayKitConfig({ cwd, configPath }) {
+	if (configPath) return loadConfiguredPayKit(cwd, path.isAbsolute(configPath) ? configPath : path.resolve(cwd, configPath));
+	for (const possiblePath of possiblePayKitConfigPaths) {
+		const resolvedPath = path.join(cwd, possiblePath);
+		if (!fs.existsSync(resolvedPath)) continue;
+		return loadConfiguredPayKit(cwd, resolvedPath);
+	}
+	throw new Error("No PayKit configuration file found. Add a `paykit.ts` file to your project or pass the path with `--config`.");
+}
+async function loadConfiguredPayKit(cwd, resolvedPath) {
+	const paykit = getPayKit(await loadModule(cwd, resolvedPath));
+	if (!paykit) throw new Error(`Couldn't read your PayKit instance in ${resolvedPath}. Export your PayKit instance as \`paykit\` or default export the result of \`createPayKit(...)\`.`);
+	return {
+		path: resolvedPath,
+		options: paykit.options
+	};
+}
+//#endregion
+export { getPayKitConfig };

package/dist/cli/utils/telemetry.js

@@ -0,0 +1,103 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { PostHog } from "posthog-node";
+//#region src/cli/utils/telemetry.ts
+const POSTHOG_KEY = "phc_y3p2bSweenGX17D90noG8YQUyqVSgHqGAY88KvjEKaJ";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+const CONFIG_DIR = path.join(os.homedir(), ".paykit");
+const TELEMETRY_FILE = path.join(CONFIG_DIR, "telemetry.json");
+const FLUSH_TIMEOUT_MS = 1e3;
+function readConfig() {
+	try {
+		const raw = fs.readFileSync(TELEMETRY_FILE, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {
+			enabled: true,
+			notified: false
+		};
+	}
+}
+function writeConfig(config) {
+	fs.mkdirSync(CONFIG_DIR, { recursive: true });
+	fs.writeFileSync(TELEMETRY_FILE, JSON.stringify(config, null, 2));
+}
+function isDisabledByEnv() {
+	return process.env.PAYKIT_TELEMETRY_DISABLED === "1" || process.env.DO_NOT_TRACK === "1";
+}
+function getAnonymousId() {
+	const raw = `${os.hostname()}:${os.userInfo().username}`;
+	return crypto.createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+function getContext() {
+	return {
+		os: process.platform,
+		arch: process.arch,
+		nodeVersion: process.version
+	};
+}
+let client = null;
+let anonymousId = null;
+function isEnabled() {
+	if (isDisabledByEnv()) return false;
+	return readConfig().enabled;
+}
+function ensureClient() {
+	if (!isEnabled()) return null;
+	if (!client) {
+		client = new PostHog(POSTHOG_KEY, {
+			host: POSTHOG_HOST,
+			flushAt: 1,
+			flushInterval: 0
+		});
+		anonymousId = getAnonymousId();
+	}
+	return client;
+}
+function showFirstRunNotice() {
+	const config = readConfig();
+	if (config.notified) return;
+	console.log("\n  PayKit collects anonymous usage data to improve the CLI.\n  Run `paykitjs telemetry disable` to opt out.\n");
+	writeConfig({
+		...config,
+		notified: true
+	});
+}
+function capture(event, properties) {
+	const posthog = ensureClient();
+	if (!posthog || !anonymousId) return;
+	showFirstRunNotice();
+	posthog.capture({
+		distinctId: anonymousId,
+		event,
+		properties: {
+			...getContext(),
+			...properties
+		}
+	});
+}
+function captureError(command, error) {
+	capture("cli_error", {
+		command,
+		error: error instanceof Error ? error.message : String(error),
+		stack: error instanceof Error ? error.stack : void 0
+	});
+}
+async function flush() {
+	if (!client) return;
+	try {
+		await Promise.race([client.shutdown(), new Promise((resolve) => setTimeout(resolve, FLUSH_TIMEOUT_MS))]);
+	} catch {}
+	client = null;
+}
+function setEnabled(enabled) {
+	writeConfig({
+		...readConfig(),
+		enabled,
+		notified: true
+	});
+}
+//#endregion
+export { capture, captureError, flush, setEnabled };

package/dist/client/index.d.ts

@@ -0,0 +1,25 @@
+import { PayKitClientApiCarrier } from "../types/instance.js";
+import { clientMethods } from "../api/methods.js";
+
+//#region src/client/index.d.ts
+type RequiresIdentify = {
+  options: {
+    identify: (...args: never[]) => unknown;
+  };
+};
+interface PayKitClientOptions {
+  baseURL?: string;
+}
+declare function createPayKitClient<Instance extends RequiresIdentify>(options?: PayKitClientOptions): InferClientAPI<Instance>;
+type CamelCase<S extends string> = S extends `${infer P1}-${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
+type PathToMethod<Path extends string, Fn> = Path extends `/${infer Segment}/${infer Rest}` ? { [K in CamelCase<Segment>]: PathToMethod<`/${Rest}`, Fn> } : Path extends `/${infer Segment}` ? { [K in CamelCase<Segment>]: Fn } : never;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type InferBody<E> = E extends ((input: infer TInput) => Promise<unknown>) ? TInput : never;
+type InferReturn<E> = E extends ((input: infer _TInput) => Promise<infer TResult>) ? TResult : never;
+type InferClientAPI<Instance> = Instance extends PayKitClientApiCarrier<infer API> ? UnionToIntersection<{ [K in keyof API]: API[K] extends {
+  path: infer P;
+} ? P extends string ? PathToMethod<P, (body: InferBody<API[K]>) => Promise<InferReturn<API[K]>>> : never : never }[keyof API]> : typeof clientMethods extends infer API ? UnionToIntersection<{ [K in keyof API]: API[K] extends {
+  path: infer P;
+} ? P extends string ? PathToMethod<P, (body: InferBody<API[K]>) => Promise<InferReturn<API[K]>>> : never : never }[keyof API]> : never;
+//#endregion
+export { PayKitClientOptions, createPayKitClient };

package/dist/client/index.js

@@ -0,0 +1,27 @@
+import { createFetch } from "@better-fetch/fetch";
+//#region src/client/index.ts
+function createPayKitClient(options) {
+	const $fetch = createFetch({
+		baseURL: options?.baseURL ?? "/paykit/api",
+		throw: true,
+		...typeof globalThis.Request !== "undefined" && "credentials" in Request.prototype ? { credentials: "include" } : {}
+	});
+	function createProxy(path = []) {
+		return new Proxy(function() {}, {
+			get(_, prop) {
+				if (typeof prop !== "string") return void 0;
+				if (prop === "then" || prop === "catch" || prop === "finally") return void 0;
+				return createProxy([...path, prop]);
+			},
+			apply: async (_, __, args) => {
+				return $fetch("/" + path.map((s) => s.replace(/[A-Z]/g, (l) => `-${l.toLowerCase()}`)).join("/"), {
+					method: "POST",
+					body: args[0] ?? {}
+				});
+			}
+		});
+	}
+	return createProxy();
+}
+//#endregion
+export { createPayKitClient };

package/dist/core/context.d.ts

@@ -0,0 +1,17 @@
+import { StripeProviderConfig, StripeRuntime } from "../providers/provider.js";
+import { PayKitDatabase } from "../database/index.js";
+import { NormalizedSchema } from "../types/schema.js";
+import { PayKitOptions } from "../types/options.js";
+import { PayKitInternalLogger } from "./logger.js";
+
+//#region src/core/context.d.ts
+interface PayKitContext {
+  options: PayKitOptions;
+  database: PayKitDatabase;
+  provider: StripeProviderConfig;
+  stripe: StripeRuntime;
+  plans: NormalizedSchema;
+  logger: PayKitInternalLogger;
+}
+//#endregion
+export { PayKitContext };

package/dist/core/context.js

@@ -0,0 +1,23 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "./errors.js";
+import { createPayKitLogger } from "./logger.js";
+import { createDatabase } from "../database/index.js";
+import { createStripeRuntime } from "../providers/stripe.js";
+import { normalizeSchema } from "../types/schema.js";
+import { Pool } from "pg";
+//#region src/core/context.ts
+async function createContext(options) {
+	if (!options.provider) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_REQUIRED);
+	if (options.basePath && !options.basePath.startsWith("/")) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.BASEPATH_INVALID, `basePath must start with "/", received "${options.basePath}"`);
+	const database = await createDatabase(typeof options.database === "string" ? new Pool({ connectionString: options.database }) : options.database);
+	const stripe = options.provider.runtime ?? createStripeRuntime(options.provider);
+	return {
+		options,
+		database,
+		provider: options.provider,
+		stripe,
+		plans: normalizeSchema(options.plans),
+		logger: createPayKitLogger(options.logging)
+	};
+}
+//#endregion
+export { createContext };

package/dist/core/create-paykit.d.ts

@@ -0,0 +1,7 @@
+import { PayKitOptions } from "../types/options.js";
+import { PayKitInstance } from "../types/instance.js";
+
+//#region src/core/create-paykit.d.ts
+declare function createPayKit<const TOptions extends PayKitOptions>(options: TOptions): PayKitInstance<TOptions>;
+//#endregion
+export { createPayKit };

package/dist/core/create-paykit.js

@@ -0,0 +1,52 @@
+import { createPayKitRouter, getApi } from "../api/methods.js";
+import { dryRunSyncProducts } from "../product/product-sync.service.js";
+import { createContext } from "./context.js";
+//#region src/core/create-paykit.ts
+const payKitInstanceSymbol = Symbol.for("paykit.instance");
+function isPayKitInstance(value) {
+	return value !== null && typeof value === "object" && value[payKitInstanceSymbol] === true;
+}
+async function initContext(options) {
+	const ctx = await createContext(options);
+	if (process.env.NODE_ENV !== "production") try {
+		const outOfSync = (await dryRunSyncProducts(ctx)).filter((r) => r.action !== "unchanged");
+		if (outOfSync.length > 0) ctx.logger.error(`${outOfSync.length} plan(s) out of sync: ${outOfSync.map((r) => r.id).join(", ")}. Run \`paykitjs push\` to update.`);
+	} catch {
+		ctx.logger.debug("Skipped plan sync check (database may not be initialized yet)");
+	}
+	return ctx;
+}
+function createPayKit(options) {
+	let contextPromise;
+	const getContext = () => {
+		contextPromise ??= initContext(options);
+		return contextPromise;
+	};
+	const paykit = {
+		options,
+		async handler(request) {
+			const ctx = await getContext();
+			const basePath = options.basePath ?? "/paykit";
+			const url = new URL(request.url);
+			if (request.method === "GET" && (url.pathname === basePath || url.pathname.startsWith(`${basePath}/`)) && !url.pathname.startsWith(`${basePath}/api`)) {
+				url.pathname = `${basePath}/api/dash`;
+				request = new Request(url, request);
+			}
+			return createPayKitRouter(ctx, options).handler(request);
+		},
+		...getApi(getContext(), options),
+		get $context() {
+			return getContext();
+		},
+		$infer: void 0
+	};
+	Object.defineProperty(paykit, payKitInstanceSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: true,
+		writable: false
+	});
+	return paykit;
+}
+//#endregion
+export { createPayKit, isPayKitInstance };

package/dist/core/error-codes.d.ts

@@ -0,0 +1,12 @@
+//#region src/core/error-codes.d.ts
+type UpperLetter = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+type IsValidUpperSnakeCase<S extends string> = S extends `${infer F}${infer R}` ? F extends UpperLetter | "_" ? IsValidUpperSnakeCase<R> : false : true;
+type InvalidKeyError<K extends string> = `Invalid error code key: "${K}" — must only contain uppercase letters (A-Z) and underscores (_)`;
+type ValidateErrorCodes<T> = { [K in keyof T]: K extends string ? IsValidUpperSnakeCase<K> extends false ? InvalidKeyError<K> : T[K] : T[K] };
+type RawError<K extends string = string> = {
+  readonly code: K;
+  message: string;
+};
+declare function defineErrorCodes<const T extends Record<string, string>, R extends { [K in keyof T & string]: RawError<K> }>(codes: ValidateErrorCodes<T>): R;
+//#endregion
+export { RawError, defineErrorCodes };

package/dist/core/error-codes.js

@@ -0,0 +1,10 @@
+//#region src/core/error-codes.ts
+function defineErrorCodes(codes) {
+	return Object.fromEntries(Object.entries(codes).map(([key, value]) => [key, {
+		code: key,
+		message: value,
+		toString: () => key
+	}]));
+}
+//#endregion
+export { defineErrorCodes };

package/dist/core/errors.d.ts

@@ -0,0 +1,41 @@
+import { RawError } from "./error-codes.js";
+import { APIError } from "better-call/error";
+
+//#region src/core/errors.d.ts
+declare const PAYKIT_ERROR_CODES: {
+  CUSTOMER_NOT_FOUND: RawError<"CUSTOMER_NOT_FOUND">;
+  CUSTOMER_CREATE_FAILED: RawError<"CUSTOMER_CREATE_FAILED">;
+  CUSTOMER_UPDATE_FAILED: RawError<"CUSTOMER_UPDATE_FAILED">;
+  PLAN_NOT_FOUND: RawError<"PLAN_NOT_FOUND">;
+  PLAN_NOT_SYNCED: RawError<"PLAN_NOT_SYNCED">;
+  PLAN_SYNC_FAILED: RawError<"PLAN_SYNC_FAILED">;
+  SUBSCRIPTION_CREATE_FAILED: RawError<"SUBSCRIPTION_CREATE_FAILED">;
+  SUBSCRIPTION_NOT_FOUND: RawError<"SUBSCRIPTION_NOT_FOUND">;
+  INVOICE_UPSERT_FAILED: RawError<"INVOICE_UPSERT_FAILED">;
+  FEATURE_UPSERT_FAILED: RawError<"FEATURE_UPSERT_FAILED">;
+  PROVIDER_REQUIRED: RawError<"PROVIDER_REQUIRED">;
+  PROVIDER_CUSTOMER_NOT_FOUND: RawError<"PROVIDER_CUSTOMER_NOT_FOUND">;
+  PROVIDER_SESSION_INVALID: RawError<"PROVIDER_SESSION_INVALID">;
+  PROVIDER_SIGNATURE_MISSING: RawError<"PROVIDER_SIGNATURE_MISSING">;
+  PROVIDER_SUBSCRIPTION_MISSING_ITEMS: RawError<"PROVIDER_SUBSCRIPTION_MISSING_ITEMS">;
+  PROVIDER_SUBSCRIPTION_MISSING_PERIOD: RawError<"PROVIDER_SUBSCRIPTION_MISSING_PERIOD">;
+  PROVIDER_PRICE_REQUIRED: RawError<"PROVIDER_PRICE_REQUIRED">;
+  PROVIDER_TEST_KEY_REQUIRED: RawError<"PROVIDER_TEST_KEY_REQUIRED">;
+  PROVIDER_WEBHOOK_INVALID: RawError<"PROVIDER_WEBHOOK_INVALID">;
+  IDENTIFY_REQUIRED: RawError<"IDENTIFY_REQUIRED">;
+  CUSTOMER_ID_MISMATCH: RawError<"CUSTOMER_ID_MISMATCH">;
+  CUSTOMER_ID_REQUIRED: RawError<"CUSTOMER_ID_REQUIRED">;
+  SUCCESS_URL_REQUIRED: RawError<"SUCCESS_URL_REQUIRED">;
+  BASEPATH_INVALID: RawError<"BASEPATH_INVALID">;
+  TESTING_NOT_ENABLED: RawError<"TESTING_NOT_ENABLED">;
+  TEST_CLOCK_NOT_FOUND: RawError<"TEST_CLOCK_NOT_FOUND">;
+};
+type PayKitErrorCode = keyof typeof PAYKIT_ERROR_CODES;
+type APIErrorStatus = ConstructorParameters<typeof APIError>[0];
+declare class PayKitError extends APIError {
+  code: string;
+  constructor(status: APIErrorStatus, error: RawError, message?: string);
+  static from(status: APIErrorStatus, error: RawError, message?: string): PayKitError;
+}
+//#endregion
+export { PAYKIT_ERROR_CODES, PayKitError, PayKitErrorCode };

package/dist/core/errors.js

@@ -0,0 +1,47 @@
+import { defineErrorCodes } from "./error-codes.js";
+import { APIError } from "better-call/error";
+//#region src/core/errors.ts
+const PAYKIT_ERROR_CODES = defineErrorCodes({
+	CUSTOMER_NOT_FOUND: "Customer not found",
+	CUSTOMER_CREATE_FAILED: "Failed to create customer",
+	CUSTOMER_UPDATE_FAILED: "Failed to update customer",
+	PLAN_NOT_FOUND: "Plan not found. Run: paykitjs push",
+	PLAN_NOT_SYNCED: "Plan is not synced with provider. Run: paykitjs push",
+	PLAN_SYNC_FAILED: "Failed to sync plan",
+	SUBSCRIPTION_CREATE_FAILED: "Failed to create subscription",
+	SUBSCRIPTION_NOT_FOUND: "Subscription not found",
+	INVOICE_UPSERT_FAILED: "Failed to upsert invoice",
+	FEATURE_UPSERT_FAILED: "Failed to upsert feature",
+	PROVIDER_REQUIRED: "A provider is required",
+	PROVIDER_CUSTOMER_NOT_FOUND: "Customer not found in provider",
+	PROVIDER_SESSION_INVALID: "Provider session did not include a URL",
+	PROVIDER_SIGNATURE_MISSING: "Missing provider webhook signature",
+	PROVIDER_SUBSCRIPTION_MISSING_ITEMS: "Provider subscription did not include any items",
+	PROVIDER_SUBSCRIPTION_MISSING_PERIOD: "Provider subscription did not include period end",
+	PROVIDER_PRICE_REQUIRED: "A provider price ID is required",
+	PROVIDER_TEST_KEY_REQUIRED: "Testing mode requires a Stripe test secret key",
+	PROVIDER_WEBHOOK_INVALID: "Provider webhook payload is invalid",
+	IDENTIFY_REQUIRED: "identify must be configured to use HTTP API routes",
+	CUSTOMER_ID_MISMATCH: "customerId does not match authenticated user",
+	CUSTOMER_ID_REQUIRED: "No customerId provided and no identify configured",
+	SUCCESS_URL_REQUIRED: "A successUrl is required when subscribe is called without a request context",
+	BASEPATH_INVALID: "basePath must start with a leading slash",
+	TESTING_NOT_ENABLED: "Testing mode is not enabled",
+	TEST_CLOCK_NOT_FOUND: "Customer does not have a test clock"
+});
+var PayKitError = class PayKitError extends APIError {
+	code;
+	constructor(status, error, message) {
+		super(status, {
+			message: message ?? error.message,
+			code: error.code
+		});
+		this.code = error.code;
+		this.name = "PayKitError";
+	}
+	static from(status, error, message) {
+		return new PayKitError(status, error, message);
+	}
+};
+//#endregion
+export { PAYKIT_ERROR_CODES, PayKitError };

package/dist/core/logger.d.ts

@@ -0,0 +1,11 @@
+import pino from "pino";
+import pretty from "pino-pretty";
+
+//#region src/core/logger.d.ts
+interface PayKitInternalLogger extends pino.Logger {
+  trace: pino.Logger["trace"] & {
+    run: <T>(prefix: string, fn: () => T | Promise<T>) => T | Promise<T>;
+  };
+}
+//#endregion
+export { PayKitInternalLogger };

package/dist/core/logger.js

@@ -0,0 +1,51 @@
+import { generateId } from "./utils.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import pino from "pino";
+import pretty from "pino-pretty";
+//#region src/core/logger.ts
+const storage = new AsyncLocalStorage();
+const PRETTY_LOG_IGNORE_FIELDS = "pid,hostname";
+const PRETTY_LOG_TIMESTAMP = "SYS:yyyy-mm-dd HH:MM:ss.l";
+const DEFAULT_LOG_LEVEL = "info";
+function getTraceId() {
+	return (storage.getStore()?.bindings())?.traceId;
+}
+function shouldUsePrettyLogs(environment = {}) {
+	const { nodeEnv = process.env.NODE_ENV } = environment;
+	return nodeEnv !== "production";
+}
+function getDefaultLoggerOptions(logging) {
+	return {
+		level: logging?.level ?? DEFAULT_LOG_LEVEL,
+		name: "paykit",
+		timestamp: pino.stdTimeFunctions.isoTime
+	};
+}
+function getPrettyLoggerOptions() {
+	return {
+		colorize: true,
+		ignore: PRETTY_LOG_IGNORE_FIELDS,
+		levelFirst: true,
+		translateTime: PRETTY_LOG_TIMESTAMP
+	};
+}
+function createPayKitLogger(logging, environment = {}) {
+	const base = logging?.logger ?? (shouldUsePrettyLogs(environment) ? pino(getDefaultLoggerOptions(logging), pretty(getPrettyLoggerOptions())) : pino(getDefaultLoggerOptions(logging)));
+	return new Proxy(base, { get(target, prop, receiver) {
+		if (prop === "trace") {
+			const current = storage.getStore() ?? target;
+			const traceFn = current.trace.bind(current);
+			traceFn.run = (prefix, fn) => {
+				const child = current.child({ traceId: generateId(prefix, 12) });
+				return storage.run(child, fn);
+			};
+			return traceFn;
+		}
+		const current = storage.getStore() ?? target;
+		const value = Reflect.get(current, prop, receiver);
+		if (typeof value === "function") return value.bind(current);
+		return value;
+	} });
+}
+//#endregion
+export { createPayKitLogger, getTraceId };

package/dist/core/utils.js

@@ -0,0 +1,21 @@
+import { webcrypto } from "node:crypto";
+//#region src/core/utils.ts
+const ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const MAX_RANDOM_BYTE = 256 - 256 % 62;
+function generateRandomString(length) {
+	let result = "";
+	const bufferSize = length + 16;
+	while (result.length < length) {
+		const bytes = webcrypto.getRandomValues(new Uint8Array(bufferSize));
+		for (const byte of bytes) if (byte < MAX_RANDOM_BYTE) {
+			result += ID_ALPHABET[byte % 62];
+			if (result.length === length) return result;
+		}
+	}
+	return result;
+}
+function generateId(prefix, length = 24) {
+	return `${prefix}_${generateRandomString(length)}`;
+}
+//#endregion
+export { generateId };