nomkit 0.0.0

package/dist/endpoints/webhooks/nomba/api.js

@@ -0,0 +1,76 @@
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+import { subscriptions } from "../../../core/pg_db/schema.js";
+import { defineNomkitMethod } from "../../../lib/utils.js";
+import { getPaymentInterval, isValidSignature } from "./utils.js";
+import z from "zod";
+import { eq } from "drizzle-orm";
+//#region endpoints/webhooks/nomba/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({ nombaWebhook: () => nombaWebhook });
+const nombaWebhook = defineNomkitMethod({
+	input: z.object({ event_type: z.enum(["payment_success", "payment_failed"]) }),
+	route: {
+		path: "/webhooks/nomba",
+		clientOnly: true,
+		requireHeaders: true
+	}
+}, async (ctx) => {
+	const db = ctx.nomkit.database;
+	const ev = ctx.input;
+	const meta = ev.data?.order?.orderMetaData;
+	if (!meta) return ctx.json({ msg: "Invalid event metadata" }, { status: 404 });
+	if (!isValidSignature({
+		headers: ctx.headers,
+		ev,
+		nomkit: ctx.nomkit
+	})) return ctx.json({ msg: "Invalid webhook payload bad signature" }, { status: 404 });
+	const subscriptionId = meta["nomkit.subscription.id"];
+	const previousSubscriptionId = meta["nomkit.subscription.previous_subscription_id"];
+	const kind = meta["nomkit.subscription.kind"];
+	const subscription = await db.query.subscriptions.findFirst({ where: { id: subscriptionId } });
+	if (!subscription) {
+		console.log("Webhook for unknown subscription");
+		return ctx.json({ msg: "Unknown webhook subscription" }, { status: 500 });
+	}
+	if (subscription.customerId !== meta["nomkit.subscription.customer_id"]) {
+		console.log("Webhook metadata customer mismatch");
+		return ctx.json({ msg: "Webhook metadata customer mismatch" }, { status: 404 });
+	}
+	if (subscription.status === "active") {
+		console.log("Already processed");
+		return ctx.json({ msg: "Already processed" });
+	}
+	if (ev.event_type === "payment_failed") {
+		console.log("Payment failed, subscription canceled");
+		await db.update(subscriptions).set({
+			status: "cancelled",
+			endedAt: /* @__PURE__ */ new Date()
+		}).where(eq(subscriptions.id, subscription.id));
+		return ctx.json({ msg: "Payment failed, subscription canceled" });
+	}
+	const plan = await db.query.products.findFirst({ where: { internalId: subscription.productInternalId } });
+	if (!plan) {
+		console.log("Subscription references missing product");
+		return ctx.json({ msg: "Subscription references missing product" });
+	}
+	const paidAt = ev.data.transaction.time;
+	const { periodStart, periodEnd } = getPaymentInterval({
+		paidAt,
+		interval: plan.priceInterval
+	});
+	await db.update(subscriptions).set({
+		status: "active",
+		currentPeriodStart: new Date(periodStart.epochMilliseconds),
+		currentPeriodEnd: new Date(periodEnd.epochMilliseconds)
+	}).where(eq(subscriptions.id, subscription.id));
+	if ((kind === "upgrade" || kind === "downgrade") && previousSubscriptionId) {
+		const previousSubscription = await db.query.subscriptions.findFirst({ where: { id: previousSubscriptionId } });
+		if (!previousSubscription) console.log("Previous subscription not found, skipping cancel");
+		else if (previousSubscription.status !== "cancelled") await db.update(subscriptions).set({
+			status: "cancelled",
+			endedAt: /* @__PURE__ */ new Date()
+		}).where(eq(subscriptions.id, previousSubscription.id));
+	}
+	return ctx.json({ msg: "Webhook processed" });
+});
+//#endregion
+export { api_exports, nombaWebhook };

package/dist/endpoints/webhooks/nomba/utils.js

@@ -0,0 +1,36 @@
+import { hashPayload } from "../../../core/nomba_api/index.js";
+import ms from "ms";
+import { Temporal } from "temporal-polyfill";
+//#region endpoints/webhooks/nomba/utils.ts
+async function isValidSignature(args) {
+	const headers = args.headers;
+	const signature = headers.get("nomba-sig-value") ?? headers.get("nomba-signature");
+	const timestamp = headers.get("nomba-timestamp");
+	if (!signature) {
+		console.log("There is no nomba-sig-value header");
+		return null;
+	}
+	if (!timestamp) {
+		console.log("There is no nomba-timestamp header");
+		return null;
+	}
+	const payload = args.ev;
+	const hash = await hashPayload({
+		payload,
+		secretKey: args.nomkit.nomba.getWebhookSecret(),
+		timestamp
+	});
+	return signature.toLowerCase() !== hash.toLowerCase();
+}
+function getPaymentInterval(args) {
+	const periodStart = Temporal.Instant.from(args.paidAt);
+	const milliseconds = ms(args.interval);
+	if (typeof milliseconds !== "number" || Number.isNaN(milliseconds)) throw new Error("You have an invalid interval");
+	if (milliseconds < 0) throw new Error("timestamp cannot include negative intervals");
+	return {
+		periodStart,
+		periodEnd: periodStart.add(Temporal.Duration.from({ milliseconds }))
+	};
+}
+//#endregion
+export { getPaymentInterval, isValidSignature };

package/dist/index.d.ts

@@ -0,0 +1,204 @@
+import { NombaAPI } from "./core/nomba_api/index.js";
+import { DatabaseConfig } from "./adapters/index.js";
+import { Customer } from "./core/pg_db/schema.js";
+import { routes } from "./queue/endpoints/routes.js";
+import { InferRouteAPI } from "./queue/client/index.js";
+import { StringValue } from "ms";
+
+//#region index.d.ts
+declare const DAYLY_INTERVAL: unique symbol;
+declare const MONTHLY_INTERVAL: unique symbol;
+declare const ANNUALLY_INTERVAL: unique symbol;
+declare const Interval: {
+  /** Defaults to `"24 hours"` */readonly DAYLY: typeof DAYLY_INTERVAL; /** Approx to `"28 days"` every cycle */
+  readonly MONTHLY: typeof MONTHLY_INTERVAL; /** Period of `"1 year"` every cycle */
+  readonly ANNUALLY: typeof ANNUALLY_INTERVAL;
+  readonly custom: <T extends StringValue>(every: T) => {
+    interval: "custom";
+    every: T;
+  };
+};
+type BuiltinInterval = Exclude<(typeof Interval)[keyof typeof Interval], typeof Interval.custom>;
+type CustomInterval = ReturnType<typeof Interval.custom>;
+type Interval = BuiltinInterval | CustomInterval;
+type Retries<T extends string = string> = {
+  interval: "custom";
+  after: T;
+};
+declare const Retry: {
+  readonly after: <const T extends StringValue>(after: T) => Retries<T>;
+};
+type Prettify<T> = { -readonly [K in keyof T]: T[K] } & {};
+interface FeatureOpts<T extends string = string> {
+  id: T;
+  label: string;
+  type: "boolean" | "metered";
+}
+type MeteredOpts = {
+  limit: number;
+  reset: "week" | "month" | "year";
+};
+type BooleanFeature<L> = () => Prettify<L>;
+type MeteredFeature<L> = <const MFeature extends MeteredOpts>(args: MFeature) => Prettify<L & MFeature>;
+type BooleanFeatureOpts<T extends string = string> = FeatureOpts<T> & {
+  type: "boolean";
+};
+type MeteredFeatureOpts<T extends string = string> = FeatureOpts<T> & {
+  type: "metered";
+};
+declare function feature<const TFeature extends BooleanFeatureOpts>(args: TFeature): BooleanFeature<TFeature>;
+declare function feature<const TFeature extends MeteredFeatureOpts>(args: TFeature): MeteredFeature<TFeature>;
+type Feature = BooleanFeatureOpts | MeteredFeatureOpts;
+interface PlanOptions<TIncludes extends readonly Feature[] = [], T extends string = string> {
+  id: T;
+  label: string;
+  includes?: TIncludes;
+  price?: {
+    /**
+     * Amount in naira
+     */
+    amount: number;
+    interval: Interval;
+  };
+}
+type Plan<TIncludes extends readonly Feature[] = [], T extends string = string> = Omit<PlanOptions<TIncludes, T>, "price"> & {
+  price?: {
+    amount: number;
+    interval: string;
+  };
+};
+declare function plan<TIncludes extends readonly Feature[] = [], const T extends string = string>(options: PlanOptions<TIncludes, T>): Plan<TIncludes, T>;
+type SubscribeOptions<TPlanId extends string> = {
+  customerId: string;
+  planID: TPlanId;
+  successURL: string;
+  cancelURL?: string;
+};
+type SubscribeResult = {
+  checkoutURL: string | null;
+};
+type CheckOptions<TFeatureId extends string> = {
+  customerId: string;
+  featureId: TFeatureId;
+};
+type CheckResult<T> = T extends {
+  type: "metered";
+} ? {
+  allowed: boolean;
+  balance: {
+    limit: number;
+    remaining: number;
+    resetAt: string;
+    unlimited: boolean;
+  };
+} : T extends {
+  type: "boolean";
+} ? {
+  allowed: boolean;
+} : never;
+type ConsumeOptions<TFeatureId> = {
+  customerId: string;
+  featureId: TFeatureId;
+  amount: number;
+};
+type ConsumeResult<TFeatureId> = {
+  featureId: TFeatureId;
+  balance: number;
+  limit: number;
+  unlimited?: boolean;
+};
+type GetCustomer = {
+  customerId?: string;
+  externalId?: string;
+};
+type GetCustomerResult = Customer | null;
+type UpsertCustomer = {
+  name?: string;
+  externalId?: string;
+  email: string;
+  metadata: Record<string, string> | null;
+};
+type ListCustomers = {
+  cursor?: string;
+  limit: number;
+};
+type ListCustomersResult = Customer[];
+type DeleteCustomer = {
+  customerId: string;
+};
+type InferBooleanFeatures<T> = T extends {
+  id: infer X;
+  type: "boolean";
+} ? X : never;
+type InferMeteredFeatures<T> = T extends {
+  id: infer X;
+  type: "metered";
+} ? X : never;
+interface NombaProvider {
+  accountId: string;
+  clientId: string;
+  clientSecret: string;
+  webhookSecret: string;
+}
+type InferRetryPolicy<T extends string> = `after:${T}`;
+type EventHandler<TArgs = unknown> = (args: TArgs) => void | Promise<void>;
+type RetryEvents<T extends string> = Partial<Record<T, EventHandler<{
+  trigger: string;
+  customer: Customer;
+}>>>;
+type DefaultEvents<R extends string> = Partial<{
+  "customer.updated": EventHandler;
+  "after:*": EventHandler<{
+    trigger: R;
+    customer: Customer;
+    isStale: boolean;
+  }>;
+}>;
+type Event<T extends string = string> = DefaultEvents<T> & RetryEvents<InferRetryPolicy<T>>;
+interface CreateNomKit<TRetries extends readonly Retries[], TProducts extends Plan<any>[] = Plan<any>[]> {
+  database: DatabaseConfig;
+  products: TProducts;
+  enableProrating?: boolean;
+  paymentProviders: {
+    nomba: NombaProvider;
+  };
+  queueConfig: {
+    baseURL: string;
+  };
+  retryPolicy: TRetries;
+  on?: Event<TRetries[number]["after"]>;
+}
+type NomKitOptions = CreateNomKit<Retries[], Plan[]>;
+interface NomkitContext {
+  database: DatabaseConfig;
+  nomba: NombaAPI;
+  queueClient: InferRouteAPI<typeof routes>;
+  on?: Event<string>;
+}
+declare function createNomkit<const TRetries extends Retries[], const TProducts extends Plan<any>[]>(args: CreateNomKit<TRetries, TProducts>): {
+  options: CreateNomKit<TRetries, TProducts>;
+  api: {
+    subscribe(data: SubscribeOptions<TProducts[number]["id"]>): Promise<SubscribeResult | null>;
+    /**
+     * Entitlements represent what a customer can currently do based on
+     * their active plan.
+     */
+    entitlements: {
+      check<T extends NonNullable<TProducts[number]["includes"]>[number]["id"]>(data: CheckOptions<T>): Promise<CheckResult<Extract<NonNullable<TProducts[number]["includes"]>[number], {
+        id: T;
+      }>>>;
+      consume<T extends InferMeteredFeatures<NonNullable<TProducts[number]["includes"]>[number]>>(data: ConsumeOptions<T>): Promise<ConsumeResult<T>>;
+    };
+    customers: {
+      get(args?: GetCustomer): Promise<GetCustomerResult>;
+      upsert(args: UpsertCustomer): Promise<boolean>;
+      list(args: ListCustomers): Promise<ListCustomersResult>;
+      delete(args: DeleteCustomer): Promise<boolean>;
+    };
+  };
+  handler(args?: {
+    basePath?: string;
+  }): (request: Request) => Promise<Response>;
+};
+//#endregion
+export { BooleanFeatureOpts, CheckOptions, CheckResult, ConsumeOptions, ConsumeResult, CreateNomKit, DeleteCustomer, Feature, FeatureOpts, GetCustomer, GetCustomerResult, InferBooleanFeatures, InferMeteredFeatures, Interval, ListCustomers, ListCustomersResult, MeteredFeatureOpts, MeteredOpts, NomKitOptions, NombaProvider, NomkitContext, Plan, Retries, Retry, SubscribeOptions, SubscribeResult, UpsertCustomer, createNomkit, feature, plan };

package/dist/index.js

@@ -0,0 +1,175 @@
+import { NombaAPI } from "./core/nomba_api/index.js";
+import { createRouterMiddleware } from "./lib/utils.js";
+import { routes } from "./endpoints/routes.js";
+import { createQueueClient } from "./queue/client/index.js";
+import { createRouter } from "better-call";
+import ms from "ms";
+//#region index.ts
+const DAYLY_INTERVAL = Symbol("24 hours");
+const MONTHLY_INTERVAL = Symbol("28 days");
+const ANNUALLY_INTERVAL = Symbol("1 year");
+const Interval = {
+	/** Defaults to `"24 hours"` */
+	DAYLY: DAYLY_INTERVAL,
+	/** Approx to `"28 days"` every cycle */
+	MONTHLY: MONTHLY_INTERVAL,
+	/** Period of `"1 year"` every cycle */
+	ANNUALLY: ANNUALLY_INTERVAL,
+	custom(every) {
+		return {
+			interval: "custom",
+			every
+		};
+	}
+};
+const Retry = { after(after) {
+	return {
+		interval: "custom",
+		after
+	};
+} };
+function feature(args) {
+	if (args.type === "boolean") return (() => args);
+	return ((input) => ({
+		...args,
+		...input
+	}));
+}
+function plan(options) {
+	enforceUniqueFeatureIds(options.includes);
+	const planPrice = enforceAmountInNaira(options.price);
+	let finalInterval = "";
+	const interval = planPrice?.interval;
+	if (interval === DAYLY_INTERVAL) finalInterval = DAYLY_INTERVAL.description;
+	if (interval === MONTHLY_INTERVAL) finalInterval = MONTHLY_INTERVAL.description;
+	if (interval === ANNUALLY_INTERVAL) finalInterval = ANNUALLY_INTERVAL.description;
+	if (typeof interval === "object" && interval?.interval === "custom") {
+		const milliseconds = ms(interval.every);
+		if (typeof milliseconds !== "number" || Number.isNaN(milliseconds)) throw new Error("You have an invalid interval");
+		if (milliseconds < 0) throw new Error("timestamp cannot include negative intervals");
+		finalInterval = interval.every;
+	}
+	const results = {
+		id: options.id,
+		label: options.label,
+		includes: options.includes
+	};
+	if (planPrice !== null) results.price = {
+		amount: Number(planPrice.amount),
+		interval: finalInterval
+	};
+	return results;
+}
+function createNomkit(args) {
+	if (!args) throw new Error("Missing required createNomkit arguments");
+	enforceUniqueProductIds(args.products);
+	const isSandbox = (process.env.IS_CREATE_NOMKIT_SANDBOX ?? "")?.length > 0;
+	const nomba = new NombaAPI({
+		accountId: args.paymentProviders.nomba.accountId,
+		clientId: args.paymentProviders.nomba.clientId,
+		clientSecret: args.paymentProviders.nomba.clientSecret,
+		webhookSecret: args.paymentProviders.nomba.webhookSecret,
+		environment: isSandbox ? "sandbox" : "production"
+	});
+	nomba.init();
+	const queueClient = createQueueClient({ baseURL: args.queueConfig.baseURL });
+	const routerContext = {
+		database: args.database,
+		nomba,
+		queueClient,
+		on: args.on
+	};
+	const router = createRouter(routes, {
+		routerContext,
+		routerMiddleware: [...createRouterMiddleware(async () => {})]
+	});
+	return {
+		options: args,
+		api: {
+			async subscribe(data) {
+				return router.endpoints.subscribe({
+					body: data,
+					context: routerContext
+				});
+			},
+			/**
+			* Entitlements represent what a customer can currently do based on
+			* their active plan.
+			*/
+			entitlements: {
+				async check(data) {
+					return router.endpoints.checkEntitlements({
+						body: data,
+						context: routerContext
+					});
+				},
+				async consume(data) {
+					return router.endpoints.consumeEntitlements({
+						body: data,
+						context: routerContext
+					});
+				}
+			},
+			customers: {
+				async get(args) {
+					return router.endpoints.getCustomer({
+						body: args ?? {},
+						context: routerContext
+					});
+				},
+				async upsert(args) {
+					return router.endpoints.upsertCustomer({
+						body: args,
+						context: routerContext
+					});
+				},
+				async list(args) {
+					return router.endpoints.listCustomers({
+						body: args,
+						context: routerContext
+					});
+				},
+				async delete(args) {
+					return router.endpoints.deleteCustomer({
+						body: args,
+						context: routerContext
+					});
+				}
+			}
+		},
+		handler(args) {
+			const { basePath = "/nomkit" } = args ?? {};
+			return async (request) => {
+				const url = new URL(request.url);
+				if (url.pathname.startsWith(basePath)) url.pathname = url.pathname.slice(basePath.length) || "/";
+				return router.handler(new Request(url, request));
+			};
+		}
+	};
+}
+function enforceUniqueProductIds(products = []) {
+	products.reduce((acc, curr) => {
+		if (acc.includes(curr.id)) throw new Error(`Product with id: "${curr.id}" already exists.`);
+		return [...acc, curr.id];
+	}, []);
+}
+function enforceUniqueFeatureIds(features = []) {
+	features.reduce((acc, curr) => {
+		if (acc.includes(curr.id)) throw new Error(`Feature with id: "${curr.id}" already exists.`);
+		return [...acc, curr.id];
+	}, []);
+}
+function enforceAmountInNaira(plan) {
+	if (plan == null) return null;
+	const { amount } = plan;
+	if (typeof amount !== "number") throw new TypeError("Plan amount must be a number expressed in naira.");
+	if (!Number.isFinite(amount)) throw new TypeError("Plan amount must be a finite number.");
+	if (amount <= 0) throw new RangeError("Plan amount must be greater than zero.");
+	if (amount < 100) throw new RangeError("Plan amount must be at least ₦100.00.");
+	return {
+		amount: amount.toFixed(2),
+		interval: plan.interval
+	};
+}
+//#endregion
+export { Interval, Retry, createNomkit, feature, plan };

package/dist/lib/utils.d.ts

@@ -0,0 +1,21 @@
+import { Endpoint, EndpointContext } from "better-call";
+import { z as z$1 } from "zod";
+
+//#region lib/utils.d.ts
+type DefineMethod<TSchema extends z$1.ZodType, TPath extends string, TRequireHeaders extends boolean = boolean, TRequireRequest extends boolean = boolean> = {
+  input: TSchema;
+  route: {
+    path: TPath;
+    requireHeaders?: TRequireRequest;
+    requireRequest?: TRequireHeaders;
+    clientOnly?: boolean;
+  };
+};
+type InferEndpoint<T> = T extends Endpoint<any, any, infer Request, any, any, infer Response, infer Metadata, any> ? {
+  request: Request;
+  response: Response;
+  metadata: Metadata;
+} : never;
+type InferRequired<R> = R extends boolean ? R : false;
+//#endregion
+export { DefineMethod, InferEndpoint, InferRequired };

package/dist/lib/utils.js

@@ -0,0 +1,41 @@
+import { getDrizzle } from "../core/pg_db/index.js";
+import { createEndpoint, createMiddleware } from "better-call";
+import { customAlphabet } from "nanoid";
+//#region lib/utils.ts
+const DEFAULT_PREFIX = "nomkit_order_";
+const generateId = customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-", 18);
+const getOrderReference = (prefix = DEFAULT_PREFIX) => {
+	const id = generateId();
+	return prefix ? `${prefix}${id}` : id;
+};
+createMiddleware(async () => void 0);
+function defineNomkitMethod(args, handler) {
+	return createEndpoint(args.route.path, {
+		method: "POST",
+		body: args.input,
+		...args.route.clientOnly === true && { metadata: { scope: "http" } }
+	}, async (ctx) => {
+		const { context = {}, body, ...baseCtx } = ctx;
+		const { database, ...nomkitCtx } = context;
+		const db = getDrizzle(database);
+		return handler({
+			...baseCtx,
+			nomkit: {
+				...nomkitCtx,
+				database: db
+			},
+			input: body
+		});
+	});
+}
+const createRouterMiddleware = (cb) => {
+	const path = "/**";
+	return [{
+		path,
+		middleware: createEndpoint(path, { method: "*" }, async (ctx) => {
+			await cb?.();
+		})
+	}];
+};
+//#endregion
+export { createRouterMiddleware, defineNomkitMethod, getOrderReference };