@mikstack/notifications 0.1.0

package/README.md

@@ -0,0 +1,119 @@
+# @mikstack/notifications
+
+Code-first notification infrastructure for mikstack projects. Factory function, plugin-based channels, Drizzle table mapping, type-safe notification definitions.
+
+## Install
+
+```sh
+bun add @mikstack/notifications
+```
+
+Peer dependency: `drizzle-orm` (>=0.38.0)
+
+## Quick Start
+
+### 1. Define your schema (copy to your `schema.ts`)
+
+```ts
+export const notificationDelivery = pgTable("notification_delivery", {
+  id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+  userId: text("user_id").notNull().references(() => user.id),
+  type: text("type").notNull(),
+  channel: text("channel").notNull(),
+  status: text("status", { enum: ["pending", "sent", "delivered", "failed"] }).notNull().default("pending"),
+  content: jsonb("content"),
+  error: text("error"),
+  retryOf: text("retry_of"),
+  retriesLeft: integer("retries_left").notNull().default(0),
+  recipientEmail: text("recipient_email"),
+  externalId: text("external_id"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+export const inAppNotification = pgTable("in_app_notification", { ... });
+export const notificationPreference = pgTable("notification_preference", { ... });
+```
+
+### 2. Define notifications
+
+```ts
+import { defineNotification } from "@mikstack/notifications";
+
+export const notifications = {
+  "magic-link": defineNotification({
+    key: "magic-link",
+    critical: true,
+    channels: {
+      email: (data: { url: string }) => magicLinkEmail(data.url),
+    },
+  }),
+  "welcome": defineNotification({
+    key: "welcome",
+    channels: {
+      "in-app": (data: { userName: string }) => ({
+        title: `Welcome, ${data.userName}!`,
+        body: "Get started by creating your first note.",
+      }),
+    },
+  }),
+} as const;
+```
+
+### 3. Create instance
+
+```ts
+import { createNotifications, emailChannel, inAppChannel } from "@mikstack/notifications";
+
+const notif = createNotifications({
+  database: { db, schema, provider: "pg" },
+  channels: [
+    emailChannel({
+      sendEmail: async ({ to, subject, html, text }) => { /* your SMTP logic */ },
+    }),
+    inAppChannel(),
+  ],
+  notifications,
+});
+```
+
+### 4. Send notifications
+
+```ts
+await notif.send({
+  type: "welcome",
+  userId: user.id,
+  data: { userName: user.name },
+});
+```
+
+## API
+
+| Method | Purpose |
+|---|---|
+| `notif.send({ type, userId, data })` | Send notification across channels |
+| `notif.list({ userId, limit?, unreadOnly? })` | List in-app notifications |
+| `notif.markRead({ userId, notificationIds? })` | Mark as read |
+| `notif.getPreferences(userId)` | Get user preferences |
+| `notif.updatePreferences(userId, prefs)` | Update preferences |
+
+## Client SDK
+
+```ts
+import { createNotificationClient } from "@mikstack/notifications/client";
+
+const client = createNotificationClient({ baseUrl: "/api/notifications" });
+await client.markRead(["notif-id-1"]);
+await client.markAllRead();
+const prefs = await client.getPreferences();
+await client.updatePreferences({ "welcome": { "in-app": false } });
+```
+
+## Features
+
+- **Type-safe**: `send()` autocompletes notification types and infers data shapes
+- **Email retries**: Exponential backoff (default 3 attempts), each attempt tracked as its own delivery row
+- **Preference hierarchy**: Per-type + per-channel > per-type + wildcard > wildcard + per-channel > defaults
+- **Critical notifications**: `critical: true` bypasses user preferences (e.g., auth emails)
+- **In-app via Zero**: `inAppNotification` table syncs to clients via Zero
+- **Schema ownership**: Tables are copy-pasted into your project (like better-auth), fully customizable

package/dist/client.d.ts

@@ -0,0 +1,21 @@
+//#region src/client-impl.d.ts
+interface NotificationClientConfig {
+  baseUrl: string;
+  fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+}
+interface NotificationClient {
+  markRead(notificationIds: string[]): Promise<void>;
+  markAllRead(): Promise<void>;
+  getPreferences(): Promise<PreferencesResponse>;
+  updatePreferences(prefs: Record<string, Record<string, boolean>>): Promise<void>;
+}
+interface PreferencesResponse {
+  preferences: {
+    notificationType: string;
+    channel: string;
+    enabled: boolean;
+  }[];
+}
+declare function createNotificationClient(config: NotificationClientConfig): NotificationClient;
+//#endregion
+export { type NotificationClient, type NotificationClientConfig, createNotificationClient };

package/dist/client.js

@@ -0,0 +1,47 @@
+//#region src/client-impl.ts
+function createNotificationClient(config) {
+	const fetchFn = config.fetch ?? globalThis.fetch;
+	const base = config.baseUrl.replace(/\/$/, "");
+	async function request(path, options) {
+		const res = await fetchFn(`${base}${path}`, {
+			headers: { "Content-Type": "application/json" },
+			...options
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "Unknown error");
+			throw new Error(`Notification API error (${res.status}): ${text}`);
+		}
+		return res;
+	}
+	return {
+		async markRead(notificationIds) {
+			await request("/mark-read", {
+				method: "POST",
+				body: JSON.stringify({ notificationIds })
+			});
+		},
+		async markAllRead() {
+			await request("/mark-read", {
+				method: "POST",
+				body: JSON.stringify({ all: true })
+			});
+		},
+		async getPreferences() {
+			return (await request("/preferences")).json();
+		},
+		async updatePreferences(prefs) {
+			const updates = Object.entries(prefs).flatMap(([notificationType, channels]) => Object.entries(channels).map(([channel, enabled]) => ({
+				notificationType,
+				channel,
+				enabled
+			})));
+			await request("/preferences", {
+				method: "PUT",
+				body: JSON.stringify({ preferences: updates })
+			});
+		}
+	};
+}
+
+//#endregion
+export { createNotificationClient };

package/dist/index.d.ts

@@ -0,0 +1,157 @@
+import { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
+
+//#region src/types.d.ts
+interface EmailContent {
+  subject: string;
+  html: string;
+  text: string;
+}
+interface InAppContent {
+  title: string;
+  body?: string;
+  url?: string;
+  icon?: string;
+}
+interface ChannelSendParams {
+  userId: string;
+  type: string;
+  content: EmailContent | InAppContent;
+  recipientEmail?: string;
+}
+interface ChannelSendResult {
+  externalId?: string;
+}
+interface ChannelHandler {
+  send(params: ChannelSendParams): Promise<ChannelSendResult>;
+}
+interface ChannelPlugin<TName extends string = string> {
+  name: TName;
+  retries: number;
+  init(ctx: ChannelInitContext): ChannelHandler;
+}
+interface ChannelInitContext {
+  db: DatabaseInstance;
+  schema: SchemaInstance;
+  tableNames: ResolvedTableNames;
+}
+type ChannelContentFn<TData, TContent> = (data: TData) => TContent;
+interface NotificationChannels<TData> {
+  email?: ChannelContentFn<TData, EmailContent>;
+  "in-app"?: ChannelContentFn<TData, InAppContent>;
+}
+interface NotificationDefinition<TKey extends string = string, TData = unknown> {
+  key: TKey;
+  description?: string;
+  critical?: boolean;
+  channels: NotificationChannels<TData>;
+}
+type NotificationDefinitions = Record<string, NotificationDefinition<string, never>>;
+type SendParams<TDefs extends NotificationDefinitions> = { [K in keyof TDefs & string]: TDefs[K] extends NotificationDefinition<string, infer TData> ? TData extends Record<string, never> ? {
+  type: K;
+  userId: string;
+  recipientEmail?: string;
+} : {
+  type: K;
+  userId: string;
+  data: TData;
+  recipientEmail?: string;
+} : never }[keyof TDefs & string];
+type DatabaseInstance = Pick<PgDatabase<PgQueryResultHKT>, "select" | "insert" | "update">;
+type SchemaInstance = Record<string, unknown>;
+interface TableNames {
+  notificationDelivery?: string;
+  inAppNotification?: string;
+  notificationPreference?: string;
+}
+interface ResolvedTableNames {
+  notificationDelivery: string;
+  inAppNotification: string;
+  notificationPreference: string;
+}
+interface DefaultPreferences {
+  enabledChannels: string[];
+}
+interface DatabaseConfig {
+  db: DatabaseInstance;
+  schema: SchemaInstance;
+  provider: "pg";
+  tableNames?: TableNames;
+}
+interface NotificationsConfig<TDefs extends NotificationDefinitions = NotificationDefinitions> {
+  database: DatabaseConfig;
+  channels: ChannelPlugin[];
+  notifications: TDefs;
+  defaultPreferences?: DefaultPreferences;
+}
+interface NotificationsInstance<TDefs extends NotificationDefinitions = NotificationDefinitions> {
+  send(params: SendParams<TDefs>): Promise<void>;
+  list(params: {
+    userId: string;
+    limit?: number;
+    unreadOnly?: boolean;
+  }): Promise<InAppNotificationRow[]>;
+  markRead(params: {
+    userId: string;
+    notificationIds?: string[];
+  }): Promise<void>;
+  getPreferences(userId: string): Promise<PreferenceRow[]>;
+  updatePreferences(userId: string, prefs: PreferenceUpdate[]): Promise<void>;
+  handler(request: Request, userId: string | null): Promise<Response>;
+  $Infer: {
+    NotificationTypes: keyof TDefs & string;
+  };
+}
+interface InAppNotificationRow {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  body: string | null;
+  url: string | null;
+  icon: string | null;
+  read: boolean;
+  createdAt: Date;
+}
+interface PreferenceRow {
+  id: string;
+  userId: string;
+  notificationType: string;
+  channel: string;
+  enabled: boolean;
+  updatedAt: Date;
+}
+interface PreferenceUpdate {
+  notificationType: string;
+  channel: string;
+  enabled: boolean;
+}
+//#endregion
+//#region src/factory.d.ts
+declare function createNotifications<TDefs extends NotificationDefinitions>(config: NotificationsConfig<TDefs>): NotificationsInstance<TDefs>;
+//#endregion
+//#region src/define.d.ts
+declare function defineNotification<TKey extends string, TData>(def: {
+  key: TKey;
+  description?: string;
+  critical?: boolean;
+  channels: NotificationChannels<TData>;
+}): NotificationDefinition<TKey, TData>;
+//#endregion
+//#region src/channels/email.d.ts
+interface EmailChannelConfig {
+  sendEmail: (params: {
+    to: string;
+    subject: string;
+    html: string;
+    text: string;
+  }) => Promise<void | {
+    externalId?: string;
+  }>;
+  retries?: number;
+}
+declare function emailChannel(config: EmailChannelConfig): ChannelPlugin<"email">;
+//#endregion
+//#region src/channels/in-app.d.ts
+declare function inAppChannel(): ChannelPlugin<"in-app">;
+//#endregion
+export { type ChannelHandler, type ChannelPlugin, type ChannelSendParams, type ChannelSendResult, type DefaultPreferences, type EmailContent, type InAppContent, type NotificationDefinition, type NotificationsConfig, type NotificationsInstance, type PreferenceUpdate, type SendParams, createNotifications, defineNotification, emailChannel, inAppChannel };

package/dist/index.js

@@ -0,0 +1,335 @@
+import { and, desc, eq } from "drizzle-orm";
+
+//#region src/internal/table.ts
+/**
+* Get a table from the schema by its configured name, throwing if not found.
+*/
+function getTable(schema, tableName, label) {
+	const table = schema[tableName];
+	if (!table) throw new Error(`Table "${tableName}" not found in schema. Make sure your schema includes the ${label} table and it's passed to createNotifications().`);
+	return table;
+}
+/**
+* Get a column from a table, asserting it exists.
+* This is needed because PgTableWithColumns column access returns `T | undefined`
+* with noUncheckedIndexedAccess enabled.
+*/
+function col(table, name) {
+	const column = table[name];
+	if (!column) throw new Error(`Column "${name}" not found on table. Check your schema definition.`);
+	return column;
+}
+
+//#endregion
+//#region src/internal/errors.ts
+var NotificationError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "NotificationError";
+	}
+};
+var DeliveryError = class extends NotificationError {
+	deliveryId;
+	constructor(deliveryId, message, options) {
+		super(message, options);
+		this.name = "DeliveryError";
+		this.deliveryId = deliveryId;
+	}
+};
+
+//#endregion
+//#region src/delivery.ts
+const DEFAULT_BACKOFF_DELAYS = [
+	1e3,
+	5e3,
+	15e3,
+	3e4,
+	6e4
+];
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function deliver(ctx, params) {
+	const table = getTable(ctx.schema, ctx.tableNames.notificationDelivery, "notificationDelivery");
+	const maxAttempts = params.retries + 1;
+	let previousDeliveryId = null;
+	let lastError;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const deliveryId = crypto.randomUUID();
+		const retriesLeft = maxAttempts - attempt - 1;
+		await ctx.db.insert(table).values({
+			id: deliveryId,
+			userId: params.userId,
+			type: params.type,
+			channel: params.channel,
+			status: "pending",
+			content: params.content,
+			retryOf: previousDeliveryId,
+			retriesLeft,
+			recipientEmail: params.recipientEmail ?? null,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		});
+		try {
+			const result = await params.handler.send({
+				userId: params.userId,
+				type: params.type,
+				content: params.content,
+				recipientEmail: params.recipientEmail
+			});
+			await ctx.db.update(table).set({
+				status: "sent",
+				externalId: result.externalId ?? null,
+				updatedAt: /* @__PURE__ */ new Date()
+			}).where(eq(col(table, "id"), deliveryId));
+			return;
+		} catch (err) {
+			lastError = err instanceof Error ? err : new Error(String(err));
+			await ctx.db.update(table).set({
+				status: "failed",
+				error: lastError.message,
+				updatedAt: /* @__PURE__ */ new Date()
+			}).where(eq(col(table, "id"), deliveryId));
+			previousDeliveryId = deliveryId;
+			if (attempt < maxAttempts - 1) {
+				const delays = params.backoffDelays ?? DEFAULT_BACKOFF_DELAYS;
+				const backoffMs = delays[Math.min(attempt, delays.length - 1)];
+				await delay(backoffMs);
+			}
+		}
+	}
+	throw new DeliveryError(previousDeliveryId, `Delivery failed after ${maxAttempts} attempt(s) on channel "${params.channel}": ${lastError?.message}`, { cause: lastError });
+}
+
+//#endregion
+//#region src/preferences.ts
+async function getPreferences(ctx, userId) {
+	const table = getTable(ctx.schema, ctx.tableNames.notificationPreference, "notificationPreference");
+	return ctx.db.select().from(table).where(eq(col(table, "userId"), userId));
+}
+async function updatePreferences(ctx, userId, prefs) {
+	const table = getTable(ctx.schema, ctx.tableNames.notificationPreference, "notificationPreference");
+	for (const pref of prefs) {
+		const existing = await ctx.db.select({ id: col(table, "id") }).from(table).where(and(eq(col(table, "userId"), userId), eq(col(table, "notificationType"), pref.notificationType), eq(col(table, "channel"), pref.channel))).limit(1);
+		if (existing.length > 0) await ctx.db.update(table).set({
+			enabled: pref.enabled,
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(eq(col(table, "id"), existing[0].id));
+		else await ctx.db.insert(table).values({
+			id: crypto.randomUUID(),
+			userId,
+			notificationType: pref.notificationType,
+			channel: pref.channel,
+			enabled: pref.enabled,
+			updatedAt: /* @__PURE__ */ new Date()
+		});
+	}
+}
+/**
+* Resolve whether a channel is enabled for a given notification type and user.
+*
+* Hierarchy (most specific wins):
+* 1. Per-user + per-type + per-channel
+* 2. Per-user + per-type + all-channels ("*")
+* 3. Per-user + all-types ("*") + per-channel
+* 4. System defaults from config
+*/
+function resolveChannelEnabled(preferences, defaults, notificationType, channel) {
+	const exact = preferences.find((p) => p.notificationType === notificationType && p.channel === channel);
+	if (exact) return exact.enabled;
+	const typeWild = preferences.find((p) => p.notificationType === notificationType && p.channel === "*");
+	if (typeWild) return typeWild.enabled;
+	const channelWild = preferences.find((p) => p.notificationType === "*" && p.channel === channel);
+	if (channelWild) return channelWild.enabled;
+	return defaults.enabledChannels.includes(channel);
+}
+
+//#endregion
+//#region src/factory.ts
+const DEFAULT_TABLE_NAMES = {
+	notificationDelivery: "notificationDelivery",
+	inAppNotification: "inAppNotification",
+	notificationPreference: "notificationPreference"
+};
+const DEFAULT_PREFERENCES = { enabledChannels: ["email", "in-app"] };
+function createNotifications(config) {
+	const { database, channels, notifications } = config;
+	const { db, schema } = database;
+	const defaults = config.defaultPreferences ?? DEFAULT_PREFERENCES;
+	const tableNames = {
+		...DEFAULT_TABLE_NAMES,
+		...database.tableNames
+	};
+	const handlers = /* @__PURE__ */ new Map();
+	const channelRetries = /* @__PURE__ */ new Map();
+	function getHandler(channelName) {
+		let handler = handlers.get(channelName);
+		if (!handler) {
+			const plugin = channels.find((c) => c.name === channelName);
+			if (!plugin) throw new NotificationError(`Channel "${channelName}" is not registered. Available channels: ${channels.map((c) => c.name).join(", ")}`);
+			handler = plugin.init({
+				db,
+				schema,
+				tableNames
+			});
+			handlers.set(channelName, handler);
+			channelRetries.set(channelName, plugin.retries);
+		}
+		return handler;
+	}
+	const instance = {
+		async send(params) {
+			const def = notifications[params.type];
+			if (!def) throw new NotificationError(`Notification type "${params.type}" is not defined.`);
+			let userPrefs = [];
+			if (!def.critical) userPrefs = await getPreferences({
+				db,
+				schema,
+				tableNames,
+				defaults
+			}, params.userId);
+			const data = "data" in params ? params.data : {};
+			const errors = [];
+			for (const [channelName, contentFn] of Object.entries(def.channels)) {
+				if (!contentFn) continue;
+				if (!def.critical && !resolveChannelEnabled(userPrefs, defaults, params.type, channelName)) continue;
+				const handler = getHandler(channelName);
+				const retries = channelRetries.get(channelName) ?? 0;
+				const content = contentFn(data);
+				try {
+					await deliver({
+						db,
+						schema,
+						tableNames
+					}, {
+						userId: params.userId,
+						type: params.type,
+						channel: channelName,
+						content,
+						recipientEmail: params.recipientEmail,
+						retries,
+						handler
+					});
+				} catch (err) {
+					errors.push(err instanceof Error ? err : new Error(String(err)));
+				}
+			}
+			if (errors.length > 0) throw new NotificationError(`Failed to deliver notification "${params.type}" on ${errors.length} channel(s)`, { cause: errors.length === 1 ? errors[0] : errors });
+		},
+		async list({ userId, limit = 50, unreadOnly = false }) {
+			const table = getTable(schema, tableNames.inAppNotification, "inAppNotification");
+			const conditions = [eq(col(table, "userId"), userId)];
+			if (unreadOnly) conditions.push(eq(col(table, "read"), false));
+			let query = db.select().from(table).$dynamic();
+			if (conditions.length === 1) query = query.where(conditions[0]);
+			else query = query.where(and(...conditions));
+			return query.orderBy(desc(col(table, "createdAt"))).limit(limit);
+		},
+		async markRead({ userId, notificationIds }) {
+			const table = getTable(schema, tableNames.inAppNotification, "inAppNotification");
+			if (notificationIds && notificationIds.length > 0) for (const id of notificationIds) await db.update(table).set({ read: true }).where(and(eq(col(table, "id"), id), eq(col(table, "userId"), userId)));
+			else await db.update(table).set({ read: true }).where(and(eq(col(table, "userId"), userId), eq(col(table, "read"), false)));
+		},
+		async getPreferences(userId) {
+			return getPreferences({
+				db,
+				schema,
+				tableNames,
+				defaults
+			}, userId);
+		},
+		async updatePreferences(userId, prefs) {
+			return updatePreferences({
+				db,
+				schema,
+				tableNames,
+				defaults
+			}, userId, prefs);
+		},
+		async handler(request, userId) {
+			if (!userId) return Response.json({ error: "Unauthorized" }, { status: 401 });
+			const path = new URL(request.url).pathname.replace(/.*\/notifications/, "").replace(/\/$/, "");
+			if (path === "/mark-read" && request.method === "POST") {
+				const body = await request.json();
+				if (body.all) await instance.markRead({ userId });
+				else if (Array.isArray(body.notificationIds)) await instance.markRead({
+					userId,
+					notificationIds: body.notificationIds
+				});
+				else return Response.json({ error: "Provide notificationIds array or { all: true }" }, { status: 400 });
+				return Response.json({ ok: true });
+			}
+			if (path === "/preferences" && request.method === "GET") {
+				const preferences = await instance.getPreferences(userId);
+				return Response.json({ preferences });
+			}
+			if (path === "/preferences" && request.method === "PUT") {
+				const body = await request.json();
+				if (!Array.isArray(body.preferences)) return Response.json({ error: "Provide a preferences array" }, { status: 400 });
+				await instance.updatePreferences(userId, body.preferences);
+				return Response.json({ ok: true });
+			}
+			return Response.json({ error: "Not found" }, { status: 404 });
+		},
+		$Infer: {}
+	};
+	return instance;
+}
+
+//#endregion
+//#region src/define.ts
+function defineNotification(def) {
+	return def;
+}
+
+//#endregion
+//#region src/channels/email.ts
+function emailChannel(config) {
+	return {
+		name: "email",
+		retries: config.retries ?? 3,
+		init() {
+			return { async send(params) {
+				const content = params.content;
+				if (!params.recipientEmail) throw new Error("recipientEmail is required for email channel. Pass it in send() or ensure it's set on the user.");
+				return { externalId: (await config.sendEmail({
+					to: params.recipientEmail,
+					subject: content.subject,
+					html: content.html,
+					text: content.text
+				}))?.externalId };
+			} };
+		}
+	};
+}
+
+//#endregion
+//#region src/channels/in-app.ts
+function inAppChannel() {
+	return {
+		name: "in-app",
+		retries: 0,
+		init(ctx) {
+			const table = getTable(ctx.schema, ctx.tableNames.inAppNotification, "inAppNotification");
+			return { async send(params) {
+				const content = params.content;
+				const id = crypto.randomUUID();
+				await ctx.db.insert(table).values({
+					id,
+					userId: params.userId,
+					type: params.type,
+					title: content.title,
+					body: content.body ?? null,
+					url: content.url ?? null,
+					icon: content.icon ?? null,
+					read: false,
+					createdAt: /* @__PURE__ */ new Date()
+				});
+				return { externalId: id };
+			} };
+		}
+	};
+}
+
+//#endregion
+export { createNotifications, defineNotification, emailChannel, inAppChannel };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@mikstack/notifications",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MikaelSiidorow/mikstack.git",
+    "directory": "packages/notifications"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown && publint && attw --pack . --profile esm-only",
+    "dev": "tsdown --watch",
+    "check": "tsc --noEmit",
+    "lint": "oxlint --type-aware --type-check && oxfmt --check src tsdown.config.ts",
+    "format": "oxfmt src tsdown.config.ts",
+    "test": "bun test"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.38.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.1",
+    "@types/bun": "^1.3.8",
+    "@types/node": "^22.15.0",
+    "drizzle-orm": "^0.45.1",
+    "oxfmt": "^0.28.0",
+    "oxlint": "^1.43.0",
+    "oxlint-tsgolint": "^0.11.4",
+    "publint": "^0.3.12",
+    "tsdown": "^0.12.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}