@sedrino/drizzle 0.0.1

package/README.md

@@ -0,0 +1,55 @@
+# @sedrino/drizzle
+
+Utilities for using Temporal with Drizzle (SQLite for now).
+
+## Install
+
+```bash
+bun add @sedrino/drizzle
+```
+
+## Usage (SQLite)
+
+```ts
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import {
+  temporalPlainDateText,
+  temporalInstantEpochMs,
+  temporalZonedDateTimeText,
+  zonedDateTimeParts,
+} from "@sedrino/drizzle/sqlite";
+
+export const tasks = sqliteTable("tasks", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  dueDate: temporalPlainDateText("due_date").nullable(),
+  createdAt: temporalInstantEpochMs("created_at_ms").notNull(),
+  startsAt: temporalZonedDateTimeText("starts_at").nullable(),
+  // startsAt: zonedDateTimeParts("starts_at"),
+});
+```
+
+## Temporal runtime
+
+Temporal is not universally available yet. We recommend `temporal-polyfill`.
+
+Option A: Install the global polyfill:
+
+```ts
+import "temporal-polyfill/global";
+```
+
+Option B: Inject the runtime explicitly:
+
+```ts
+import { Temporal } from "temporal-polyfill";
+import { temporalPlainDateTimeText } from "@sedrino/drizzle/sqlite";
+
+const createdAt = temporalPlainDateTimeText("created_at", { Temporal });
+```
+
+## Types
+
+This package relies on the `temporal-polyfill` type definitions for `Temporal`.
+If your app uses a different runtime, you can still use these types without
+installing a polyfill globally.

package/dist/sqlite.d.ts

@@ -0,0 +1,117 @@
+import { customType, integer, text } from "drizzle-orm/sqlite-core";
+import "temporal-polyfill/global";
+/**
+ * Runtime Temporal resolution:
+ * - pass { Temporal } from "@js-temporal/polyfill" if needed
+ * - otherwise uses globalThis.Temporal
+ */
+export type TemporalRuntime = typeof Temporal;
+type SmallestUnit = "minute" | "second" | "millisecond" | "microsecond" | "nanosecond";
+type ToStringPrecision = {
+    smallestUnit?: SmallestUnit;
+    roundingMode?: "ceil" | "floor" | "trunc" | "halfExpand";
+};
+/** PlainDate -> TEXT "YYYY-MM-DD" */
+export declare const temporalPlainDateText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.PlainDate;
+    driverData: string;
+}>>>;
+/** PlainTime -> TEXT "HH:mm:ss.sssssssss" (precision controlled via smallestUnit) */
+export declare const temporalPlainTimeText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+    precision?: ToStringPrecision;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.PlainTime;
+    driverData: string;
+}>>>;
+/** PlainDateTime -> TEXT "YYYY-MM-DDTHH:mm:ss.sssssssss" */
+export declare const temporalPlainDateTimeText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+    precision?: ToStringPrecision;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.PlainDateTime;
+    driverData: string;
+}>>>;
+/** PlainYearMonth -> TEXT "YYYY-MM" (plus optional calendar annotation if non-ISO) */
+export declare const temporalPlainYearMonthText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.PlainYearMonth;
+    driverData: string;
+}>>>;
+/** PlainMonthDay -> TEXT "MM-DD" (plus optional calendar annotation if non-ISO) */
+export declare const temporalPlainMonthDayText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.PlainMonthDay;
+    driverData: string;
+}>>>;
+/**
+ * Duration -> TEXT ISO-8601, e.g. "PT15M", "P2DT3H"
+ * Note: if millis/micros/nanos exceed 999, parsing back yields an
+ * equal-but-differently-balanced Duration.
+ */
+export declare const temporalDurationText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.Duration;
+    driverData: string;
+}>>>;
+/**
+ * Instant (recommended) -> INTEGER epoch milliseconds
+ * Great for sorting/filtering by actual time.
+ * Tradeoff: millisecond precision only.
+ */
+export declare const temporalInstantEpochMs: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.Instant;
+    driverData: number;
+    driverOutput: number | string;
+}>>>;
+/**
+ * Instant (lossless) -> TEXT ISO string, e.g. "2026-01-25T12:34:56.123456789Z"
+ * Tradeoff: sorting by TEXT is chronological only if the format is stable.
+ */
+export declare const temporalInstantIsoText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+    precision?: ToStringPrecision;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.Instant;
+    driverData: string;
+}>>>;
+/**
+ * ZonedDateTime (single-column) -> TEXT with zone annotation.
+ * Example: "2026-01-25T09:00:00-05:00[America/New_York]"
+ *
+ * This is convenient, but if you need sorting/filtering by actual moment,
+ * prefer the multi-column helper below (epochMs + timeZoneId + calendarId).
+ */
+export declare const temporalZonedDateTimeText: (name: string, opts?: {
+    Temporal?: TemporalRuntime;
+    precision?: ToStringPrecision;
+}) => ReturnType<ReturnType<typeof customType<{
+    data: Temporal.ZonedDateTime;
+    driverData: string;
+}>>>;
+/** Recommended storage shape for ZonedDateTime: epochMs + timeZoneId (+ calendarId). */
+export declare const zonedDateTimeParts: (prefix: string) => {
+    epochMs: ReturnType<typeof integer>;
+    timeZoneId: ReturnType<typeof text>;
+    calendarId: ReturnType<typeof text>;
+};
+export declare function packZonedDateTime(zdt: Temporal.ZonedDateTime): {
+    epochMs: number;
+    timeZoneId: string;
+    calendarId: string;
+};
+export declare function unpackZonedDateTime(parts: {
+    epochMs: number;
+    timeZoneId: string;
+    calendarId?: string;
+}, opts?: {
+    Temporal?: TemporalRuntime;
+}): Temporal.ZonedDateTime;
+export {};

package/dist/sqlite.js

@@ -0,0 +1,142 @@
+import { customType, integer, text } from "drizzle-orm/sqlite-core";
+import "temporal-polyfill/global";
+function requireTemporal(runtime) {
+    const T = runtime ?? globalThis.Temporal;
+    if (!T) {
+        throw new Error("Temporal is not available at runtime. Pass { Temporal } from @js-temporal/polyfill or run in an environment with Temporal.");
+    }
+    return T;
+}
+/**
+ * Stable fixed-width-ish defaults for DB persistence.
+ * (Change smallestUnit to "millisecond" if you want shorter strings.)
+ */
+const DEFAULT_PRECISION = {
+    smallestUnit: "nanosecond",
+    roundingMode: "trunc",
+};
+/** PlainDate -> TEXT "YYYY-MM-DD" */
+export const temporalPlainDateText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(),
+        fromDriver: (v) => T.PlainDate.from(v),
+    })(name);
+};
+/** PlainTime -> TEXT "HH:mm:ss.sssssssss" (precision controlled via smallestUnit) */
+export const temporalPlainTimeText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    const p = { ...DEFAULT_PRECISION, ...opts?.precision };
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(p),
+        fromDriver: (v) => T.PlainTime.from(v),
+    })(name);
+};
+/** PlainDateTime -> TEXT "YYYY-MM-DDTHH:mm:ss.sssssssss" */
+export const temporalPlainDateTimeText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    const p = { ...DEFAULT_PRECISION, ...opts?.precision };
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(p),
+        fromDriver: (v) => T.PlainDateTime.from(v),
+    })(name);
+};
+/** PlainYearMonth -> TEXT "YYYY-MM" (plus optional calendar annotation if non-ISO) */
+export const temporalPlainYearMonthText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(),
+        fromDriver: (v) => T.PlainYearMonth.from(v),
+    })(name);
+};
+/** PlainMonthDay -> TEXT "MM-DD" (plus optional calendar annotation if non-ISO) */
+export const temporalPlainMonthDayText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(),
+        fromDriver: (v) => T.PlainMonthDay.from(v),
+    })(name);
+};
+/**
+ * Duration -> TEXT ISO-8601, e.g. "PT15M", "P2DT3H"
+ * Note: if millis/micros/nanos exceed 999, parsing back yields an
+ * equal-but-differently-balanced Duration.
+ */
+export const temporalDurationText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(),
+        fromDriver: (v) => T.Duration.from(v),
+    })(name);
+};
+/**
+ * Instant (recommended) -> INTEGER epoch milliseconds
+ * Great for sorting/filtering by actual time.
+ * Tradeoff: millisecond precision only.
+ */
+export const temporalInstantEpochMs = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    return customType({
+        dataType: () => "integer",
+        toDriver: (v) => v.epochMilliseconds,
+        fromDriver: (v) => T.Instant.fromEpochMilliseconds(typeof v === "string" ? Number(v) : v),
+        fromJson: (v) => T.Instant.fromEpochMilliseconds(typeof v === "string" ? Number(v) : v),
+    })(name);
+};
+/**
+ * Instant (lossless) -> TEXT ISO string, e.g. "2026-01-25T12:34:56.123456789Z"
+ * Tradeoff: sorting by TEXT is chronological only if the format is stable.
+ */
+export const temporalInstantIsoText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    const p = { ...DEFAULT_PRECISION, ...opts?.precision };
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString(p),
+        fromDriver: (v) => T.Instant.from(v),
+    })(name);
+};
+/**
+ * ZonedDateTime (single-column) -> TEXT with zone annotation.
+ * Example: "2026-01-25T09:00:00-05:00[America/New_York]"
+ *
+ * This is convenient, but if you need sorting/filtering by actual moment,
+ * prefer the multi-column helper below (epochMs + timeZoneId + calendarId).
+ */
+export const temporalZonedDateTimeText = (name, opts) => {
+    const T = requireTemporal(opts?.Temporal);
+    const p = { ...DEFAULT_PRECISION, ...opts?.precision };
+    return customType({
+        dataType: () => "text",
+        toDriver: (v) => v.toString({ ...p, timeZoneName: "auto" }),
+        fromDriver: (v) => T.ZonedDateTime.from(v),
+    })(name);
+};
+/* ------------------------------------------------------------------------------------------------
+ * Multi-column (“flattened”) helpers
+ * customType is 1-column <-> 1-value, so for “parts” you define multiple columns + pack/unpack.
+ * ------------------------------------------------------------------------------------------------ */
+/** Recommended storage shape for ZonedDateTime: epochMs + timeZoneId (+ calendarId). */
+export const zonedDateTimeParts = (prefix) => ({
+    epochMs: integer(`${prefix}_epoch_ms`).notNull(),
+    timeZoneId: text(`${prefix}_tz`).notNull(),
+    calendarId: text(`${prefix}_cal`).notNull().default("iso8601"),
+});
+export function packZonedDateTime(zdt) {
+    return {
+        epochMs: zdt.epochMilliseconds,
+        timeZoneId: zdt.timeZoneId,
+        calendarId: zdt.calendarId,
+    };
+}
+export function unpackZonedDateTime(parts, opts) {
+    const T = requireTemporal(opts?.Temporal);
+    const zdt = T.Instant.fromEpochMilliseconds(parts.epochMs).toZonedDateTimeISO(parts.timeZoneId);
+    return parts.calendarId ? zdt.withCalendar(parts.calendarId) : zdt;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@sedrino/drizzle",
+  "version": "0.0.1",
+  "main": "./dist/sqlite.js",
+  "types": "./dist/sqlite.d.ts",
+  "exports": {
+    "./sqlite": {
+      "types": "./dist/sqlite.d.ts",
+      "default": "./dist/sqlite.js"
+    }
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "temporal-polyfill": "^0.3.0",
+    "drizzle-orm": "^1.0.0-beta.9"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.6.3"
+  },
+  "scripts": {
+    "build": "bunx tsc -p tsconfig.build.json"
+  }
+}