@apiagex/database 0.6.4 → 0.8.1

package/dist/realtime-repository.js

@@ -1,14 +1,14 @@
 import { randomUUID } from "node:crypto";
 import { getSchemaById, listSchemas } from "./schema-repository.js";
 const allowedEvents = new Set(["entry.created", "entry.updated", "entry.deleted"]);
-export function listRealtimeConfigs(db) {
-    const rows = db.prepare(realtimeSelectSql("ORDER BY updated_at DESC")).all();
+export async function listRealtimeConfigs(db) {
+    const rows = await db.prepare(realtimeSelectSql("ORDER BY updated_at DESC")).all();
     return rows.map(rowToRealtimeConfig);
 }
-export function listRealtimeSettings(db) {
-    const configs = new Map(listRealtimeConfigs(db).map((config) => [config.schemaId, config]));
+export async function listRealtimeSettings(db) {
+    const configs = new Map((await listRealtimeConfigs(db)).map((config) => [config.schemaId, config]));
     const now = new Date().toISOString();
-    return listSchemas(db).map((schema) => configs.get(schema.id) ?? {
+    return (await listSchemas(db)).map((schema) => configs.get(schema.id) ?? {
         schemaId: schema.id,
         enabled: false,
         events: ["entry.created", "entry.updated", "entry.deleted"],
@@ -16,52 +16,62 @@ export function listRealtimeSettings(db) {
         updatedAt: now,
     });
 }
-export function getRealtimeConfig(db, schemaId) {
-    const row = db.prepare(realtimeSelectSql("WHERE schema_id = ?")).get(schemaId);
+export async function getRealtimeConfig(db, schemaId) {
+    const row = await db.prepare(realtimeSelectSql("WHERE schema_id = ?")).get(schemaId);
     return row ? rowToRealtimeConfig(row) : undefined;
 }
-export function setRealtimeConfig(db, input) {
+export async function setRealtimeConfig(db, input) {
     const events = normalizeEvents(input.events);
-    if (!getSchemaById(db, input.schemaId))
+    if (!(await getSchemaById(db, input.schemaId)))
         throw new Error("SCHEMA_NOT_FOUND");
     const now = new Date().toISOString();
-    db.prepare(`INSERT INTO realtime_configs (schema_id, enabled, events_json, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?)
-     ON CONFLICT(schema_id) DO UPDATE SET enabled = excluded.enabled,
-       events_json = excluded.events_json,
-       updated_at = excluded.updated_at`).run(input.schemaId, input.enabled ? 1 : 0, JSON.stringify(events), now, now);
-    return getRealtimeConfig(db, input.schemaId);
+    const existing = await getRealtimeConfig(db, input.schemaId);
+    if (existing) {
+        await db.prepare("UPDATE realtime_configs SET enabled = ?, events_json = ?, updated_at = ? WHERE schema_id = ?")
+            .run(input.enabled ? 1 : 0, JSON.stringify(events), now, input.schemaId);
+    }
+    else {
+        await db.prepare("INSERT INTO realtime_configs (schema_id, enabled, events_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(input.schemaId, input.enabled ? 1 : 0, JSON.stringify(events), now, now);
+    }
+    const config = await getRealtimeConfig(db, input.schemaId);
+    if (!config)
+        throw new Error("REALTIME_CONFIG_NOT_FOUND");
+    return config;
 }
-export function isRealtimeEventEnabled(db, schemaId, event) {
-    const config = getRealtimeConfig(db, schemaId);
+export async function isRealtimeEventEnabled(db, schemaId, event) {
+    const config = await getRealtimeConfig(db, schemaId);
     return Boolean(config?.enabled && config.events.includes(event));
 }
-export function recordRealtimeEvent(db, input) {
+export async function recordRealtimeEvent(db, input) {
     const now = new Date().toISOString();
     const id = `rte_${randomUUID()}`;
     const messageId = `rtm_${randomUUID()}`;
-    db.prepare(`INSERT INTO realtime_events
+    await db.prepare(`INSERT INTO realtime_events
       (id, message_id, event_type, schema_id, schema_slug, entry_id, entry_json, occurred_at, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, messageId, input.eventType, input.schemaId, input.schemaSlug, input.entry.id, JSON.stringify(input.entry), now, now);
-    return rowToRealtimeEvent(db.prepare(realtimeEventSelectSql("WHERE id = ?")).get(id));
+    const row = await db.prepare(realtimeEventSelectSql("WHERE id = ?")).get(id);
+    if (!row)
+        throw new Error("REALTIME_EVENT_NOT_FOUND");
+    return rowToRealtimeEvent(row);
 }
-export function listRealtimeEventsAfter(db, schemaId, lastEventId, limit = 50) {
-    const last = db.prepare("SELECT sequence FROM realtime_events WHERE id = ? AND schema_id = ?")
+export async function listRealtimeEventsAfter(db, schemaId, lastEventId, limit = 50) {
+    const last = await db.prepare("SELECT sequence FROM realtime_events WHERE id = ? AND schema_id = ?")
         .get(lastEventId, schemaId);
     if (!last)
         return [];
-    const rows = db.prepare(realtimeEventSelectSql("WHERE schema_id = ? AND sequence > ? ORDER BY sequence ASC LIMIT ?"))
+    const rows = await db
+        .prepare(realtimeEventSelectSql("WHERE schema_id = ? AND sequence > ? ORDER BY sequence ASC LIMIT ?"))
         .all(schemaId, last.sequence, Math.max(1, Math.min(limit, 100)));
     return rows.map(rowToRealtimeEvent);
 }
-export function listRecentRealtimeEvents(db, limit = 25) {
-    const rows = db.prepare(realtimeEventSelectSql("ORDER BY sequence DESC LIMIT ?"))
+export async function listRecentRealtimeEvents(db, limit = 25) {
+    const rows = await db.prepare(realtimeEventSelectSql("ORDER BY sequence DESC LIMIT ?"))
         .all(Math.max(1, Math.min(limit, 100)));
     return rows.map(rowToRealtimeEvent);
 }
-export function pruneRealtimeEvents(db, schemaId, keepLatest = 1000) {
+export async function pruneRealtimeEvents(db, schemaId, keepLatest = 1000) {
     const keep = Math.max(1, keepLatest);
-    const result = db.prepare(`DELETE FROM realtime_events
+    const result = await db.prepare(`DELETE FROM realtime_events
      WHERE schema_id = ?
        AND sequence NOT IN (
          SELECT sequence FROM realtime_events

package/dist/realtime-session-repository.d.ts

@@ -1,5 +1,5 @@
-import type { SqliteDatabase } from "./sqlite.js";
+import type { ApiagexDatabase } from "./database-adapter.type.js";
 import type { CreatedRealtimeSession, CreateRealtimeSessionInput, RealtimeSessionRecord } from "./realtime-session-repository.type.js";
-export declare function createRealtimeSession(db: SqliteDatabase, input: CreateRealtimeSessionInput): CreatedRealtimeSession;
-export declare function consumeRealtimeSession(db: SqliteDatabase, token: string, schemaSlug: string, now?: Date): RealtimeSessionRecord | undefined;
+export declare function createRealtimeSession(db: ApiagexDatabase, input: CreateRealtimeSessionInput): Promise<CreatedRealtimeSession>;
+export declare function consumeRealtimeSession(db: ApiagexDatabase, token: string, schemaSlug: string, now?: Date): Promise<RealtimeSessionRecord | undefined>;
 //# sourceMappingURL=realtime-session-repository.d.ts.map

package/dist/realtime-session-repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"realtime-session-repository.d.ts","sourceRoot":"","sources":["../src/realtime-session-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,uCAAuC,CAAC;AAI/C,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,0BAA0B,GAAG,sBAAsB,CAoBnH;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,GAAG,OAAa,GACf,qBAAqB,GAAG,SAAS,CAQnC"}
+{"version":3,"file":"realtime-session-repository.d.ts","sourceRoot":"","sources":["../src/realtime-session-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,uCAAuC,CAAC;AAI/C,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,sBAAsB,CAAC,CAoBjC;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,GAAG,OAAa,GACf,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CAS5C"}

package/dist/realtime-session-repository.js

@@ -1,31 +1,31 @@
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-export function createRealtimeSession(db, input) {
+export async function createRealtimeSession(db, input) {
     const now = new Date();
     const ttlSeconds = Math.max(30, Math.min(input.ttlSeconds ?? 300, 900));
     const token = `rt_${randomBytes(32).toString("base64url")}`;
     const id = randomUUID();
-    db.prepare(`INSERT INTO realtime_sessions
+    await db.prepare(`INSERT INTO realtime_sessions
       (id, token_hash, token_prefix, role_id, schema_id, schema_slug, created_at, expires_at, used_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`).run(id, hashToken(token), token.slice(0, 12), input.roleId, input.schemaId, input.schemaSlug, now.toISOString(), new Date(now.getTime() + ttlSeconds * 1000).toISOString());
-    return { token, session: requireRealtimeSession(db, id) };
+    return { token, session: await requireRealtimeSession(db, id) };
 }
-export function consumeRealtimeSession(db, token, schemaSlug, now = new Date()) {
-    const row = db.prepare(sessionSelectSql("WHERE token_hash = ? AND schema_slug = ?"))
+export async function consumeRealtimeSession(db, token, schemaSlug, now = new Date()) {
+    const row = await db
+        .prepare(sessionSelectSql("WHERE token_hash = ? AND schema_slug = ?"))
         .get(hashToken(token), schemaSlug);
     if (!row || row.usedAt || Date.parse(row.expiresAt) <= now.getTime())
         return undefined;
-    const result = db.prepare("UPDATE realtime_sessions SET used_at = ? WHERE id = ? AND used_at IS NULL")
+    const result = await db.prepare("UPDATE realtime_sessions SET used_at = ? WHERE id = ? AND used_at IS NULL")
         .run(now.toISOString(), row.id);
     if (result.changes !== 1)
         return undefined;
     return getRealtimeSessionById(db, row.id);
 }
-function getRealtimeSessionById(db, id) {
-    const row = db.prepare(sessionSelectSql("WHERE id = ?")).get(id);
-    return row;
+async function getRealtimeSessionById(db, id) {
+    return db.prepare(sessionSelectSql("WHERE id = ?")).get(id);
 }
-function requireRealtimeSession(db, id) {
-    const session = getRealtimeSessionById(db, id);
+async function requireRealtimeSession(db, id) {
+    const session = await getRealtimeSessionById(db, id);
     if (!session)
         throw new Error("REALTIME_SESSION_NOT_FOUND");
     return session;

package/dist/relation-helpers.d.ts

@@ -1,14 +1,14 @@
+import type { ApiagexDatabase, DatabaseQueryParam } from "./database-adapter.type.js";
 import type { EntryData } from "./entry-repository.type.js";
 import type { FieldRecord, RelationType } from "./schema-repository.type.js";
-import type { SqliteDatabase } from "./sqlite.js";
 type EntryDataRow = {
     dataJson: string;
     id: string;
 };
 export declare function relationTypeOf(field: FieldRecord): RelationType;
 export declare function entryDataReferences(data: EntryData, entryId: string): boolean;
-export declare function listEntryDataRows(db: SqliteDatabase, where?: string, params?: unknown[]): EntryDataRow[];
+export declare function listEntryDataRows(db: ApiagexDatabase, where?: string, params?: DatabaseQueryParam[]): Promise<EntryDataRow[]>;
 export declare function parseEntryData(dataJson: string): EntryData;
-export declare function schemaEntriesUseField(db: SqliteDatabase, schemaId: string, fieldSlug: string): boolean;
+export declare function schemaEntriesUseField(db: ApiagexDatabase, schemaId: string, fieldSlug: string): Promise<boolean>;
 export {};
 //# sourceMappingURL=relation-helpers.d.ts.map

package/dist/relation-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relation-helpers.d.ts","sourceRoot":"","sources":["../src/relation-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,KAAK,YAAY,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAE/D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAI7E;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,SAAK,EAAE,MAAM,GAAE,OAAO,EAAO,GAAG,YAAY,EAAE,CAIxG;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAE1D;AAED,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,cAAc,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAMT"}
+{"version":3,"file":"relation-helpers.d.ts","sourceRoot":"","sources":["../src/relation-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE7E,KAAK,YAAY,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAE/D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAI7E;AAED,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,eAAe,EACnB,KAAK,SAAK,EACV,MAAM,GAAE,kBAAkB,EAAO,GAChC,OAAO,CAAC,YAAY,EAAE,CAAC,CAEzB;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAE1D;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,eAAe,EACnB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAMlB"}

package/dist/relation-helpers.js

@@ -4,16 +4,14 @@ export function relationTypeOf(field) {
 export function entryDataReferences(data, entryId) {
     return Object.values(data).some((value) => value === entryId || (Array.isArray(value) && value.includes(entryId)));
 }
-export function listEntryDataRows(db, where = "", params = []) {
-    return db
-        .prepare(`SELECT id, data_json as dataJson FROM entries ${where}`)
-        .all(...params);
+export async function listEntryDataRows(db, where = "", params = []) {
+    return db.prepare(`SELECT id, data_json as dataJson FROM entries ${where}`).all(...params);
 }
 export function parseEntryData(dataJson) {
     return JSON.parse(dataJson);
 }
-export function schemaEntriesUseField(db, schemaId, fieldSlug) {
-    const rows = listEntryDataRows(db, "WHERE schema_id = ?", [schemaId]);
+export async function schemaEntriesUseField(db, schemaId, fieldSlug) {
+    const rows = await listEntryDataRows(db, "WHERE schema_id = ?", [schemaId]);
     return rows.some((row) => {
         const value = parseEntryData(row.dataJson)[fieldSlug];
         return value !== undefined && value !== null && value !== "";

package/dist/role-repository.d.ts

@@ -1,8 +1,8 @@
-import type { SqliteDatabase } from "./sqlite.js";
+import type { ApiagexDatabase } from "./database-adapter.type.js";
 import type { CreateRoleInput, RoleRecord } from "./role-repository.type.js";
-export declare function createRole(db: SqliteDatabase, input: CreateRoleInput): RoleRecord;
-export declare function createAdminRole(db: SqliteDatabase, input: CreateRoleInput): RoleRecord;
-export declare function listRoles(db: SqliteDatabase): RoleRecord[];
-export declare function listAdminRoles(db: SqliteDatabase): RoleRecord[];
-export declare function getRoleById(db: SqliteDatabase, id: string): RoleRecord | undefined;
+export declare function createRole(db: ApiagexDatabase, input: CreateRoleInput): Promise<RoleRecord>;
+export declare function createAdminRole(db: ApiagexDatabase, input: CreateRoleInput): Promise<RoleRecord>;
+export declare function listRoles(db: ApiagexDatabase): Promise<RoleRecord[]>;
+export declare function listAdminRoles(db: ApiagexDatabase): Promise<RoleRecord[]>;
+export declare function getRoleById(db: ApiagexDatabase, id: string): Promise<RoleRecord | undefined>;
 //# sourceMappingURL=role-repository.d.ts.map

package/dist/role-repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"role-repository.d.ts","sourceRoot":"","sources":["../src/role-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAO7E,wBAAgB,UAAU,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAQjF;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAQtF;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,cAAc,GAAG,UAAU,EAAE,CAK1D;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,cAAc,GAAG,UAAU,EAAE,CAK/D;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAGlF"}
+{"version":3,"file":"role-repository.d.ts","sourceRoot":"","sources":["../src/role-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAO7E,wBAAsB,UAAU,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAQjG;AAED,wBAAsB,eAAe,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAQtG;AAED,wBAAsB,SAAS,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAG1E;AAED,wBAAsB,cAAc,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAK/E;AAED,wBAAsB,WAAW,CAAC,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAGlG"}

package/dist/role-repository.js

@@ -1,61 +1,54 @@
 import { randomUUID } from "node:crypto";
 const roleNamePattern = /^[a-z][a-z0-9-]*$/;
 const adminRoleNames = new Set(["owner", "admin", "schema-manager", "user-manager"]);
-export function createRole(db, input) {
+export async function createRole(db, input) {
     validateApiRole(input);
     const id = randomUUID();
     const now = new Date().toISOString();
-    db.prepare("INSERT INTO roles (id, name, description, is_owner, role_kind, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, input.name, input.description ?? "", 0, "api", now, now);
+    await db.prepare("INSERT INTO roles (id, name, description, is_owner, role_kind, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, input.name, input.description ?? "", 0, "api", now, now);
     return requireRole(db, id);
 }
-export function createAdminRole(db, input) {
+export async function createAdminRole(db, input) {
     validateAdminRole(input);
     const id = randomUUID();
     const now = new Date().toISOString();
-    db.prepare("INSERT INTO roles (id, name, description, is_owner, role_kind, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, input.name, input.description ?? "", 0, "admin", now, now);
+    await db.prepare("INSERT INTO roles (id, name, description, is_owner, role_kind, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, input.name, input.description ?? "", 0, "admin", now, now);
     return requireRole(db, id);
 }
-export function listRoles(db) {
-    const rows = db
-        .prepare(roleSelectSql("WHERE role_kind = 'api' ORDER BY created_at ASC"))
-        .all();
+export async function listRoles(db) {
+    const rows = await db.prepare(roleSelectSql("WHERE role_kind = 'api' ORDER BY created_at ASC")).all();
     return rows.map(rowToRole);
 }
-export function listAdminRoles(db) {
-    const rows = db
+export async function listAdminRoles(db) {
+    const rows = await db
         .prepare(roleSelectSql("WHERE role_kind = 'admin' ORDER BY is_owner DESC, created_at ASC"))
         .all();
     return rows.map(rowToRole);
 }
-export function getRoleById(db, id) {
-    const row = db.prepare(roleSelectSql("WHERE id = ?")).get(id);
+export async function getRoleById(db, id) {
+    const row = await db.prepare(roleSelectSql("WHERE id = ?")).get(id);
     return row ? rowToRole(row) : undefined;
 }
 function validateApiRole(input) {
     validateRoleName(input);
-    if (input.name === "owner") {
+    if (input.name === "owner")
         throw new Error("ROLE_OWNER_RESERVED");
-    }
-    if (adminRoleNames.has(input.name)) {
+    if (adminRoleNames.has(input.name))
         throw new Error("ROLE_ADMIN_RESERVED");
-    }
 }
 function validateAdminRole(input) {
     validateRoleName(input);
-    if (input.name === "owner") {
+    if (input.name === "owner")
         throw new Error("ROLE_OWNER_RESERVED");
-    }
 }
 function validateRoleName(input) {
-    if (!roleNamePattern.test(input.name)) {
+    if (!roleNamePattern.test(input.name))
         throw new Error("ROLE_NAME_INVALID");
-    }
 }
-function requireRole(db, id) {
-    const role = getRoleById(db, id);
-    if (!role) {
+async function requireRole(db, id) {
+    const role = await getRoleById(db, id);
+    if (!role)
         throw new Error("ROLE_NOT_FOUND");
-    }
     return role;
 }
 function rowToRole(row) {

package/dist/schema-repository.d.ts

@@ -1,9 +1,9 @@
-import type { SqliteDatabase } from "./sqlite.js";
+import type { ApiagexDatabase } from "./database-adapter.type.js";
 import type { CreateSchemaInput, SchemaRecord, UpdateSchemaInput } from "./schema-repository.type.js";
-export declare function createSchema(db: SqliteDatabase, input: CreateSchemaInput): SchemaRecord;
-export declare function listSchemas(db: SqliteDatabase): SchemaRecord[];
-export declare function getSchemaById(db: SqliteDatabase, id: string): SchemaRecord | undefined;
-export declare function getSchemaBySlug(db: SqliteDatabase, slug: string): SchemaRecord | undefined;
-export declare function updateSchema(db: SqliteDatabase, id: string, input: UpdateSchemaInput): SchemaRecord;
-export declare function deleteSchema(db: SqliteDatabase, id: string): void;
+export declare function createSchema(db: ApiagexDatabase, input: CreateSchemaInput): Promise<SchemaRecord>;
+export declare function listSchemas(db: ApiagexDatabase): Promise<SchemaRecord[]>;
+export declare function getSchemaById(db: ApiagexDatabase, id: string): Promise<SchemaRecord | undefined>;
+export declare function getSchemaBySlug(db: ApiagexDatabase, slug: string): Promise<SchemaRecord | undefined>;
+export declare function updateSchema(db: ApiagexDatabase, id: string, input: UpdateSchemaInput): Promise<SchemaRecord>;
+export declare function deleteSchema(db: ApiagexDatabase, id: string): Promise<void>;
 //# sourceMappingURL=schema-repository.d.ts.map

package/dist/schema-repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-repository.d.ts","sourceRoot":"","sources":["../src/schema-repository.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAEV,iBAAiB,EAIjB,YAAY,EACZ,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAoBrC,wBAAgB,YAAY,CAC1B,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,iBAAiB,GACvB,YAAY,CAmBd;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,YAAY,EAAE,CAK9D;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,cAAc,EAClB,EAAE,EAAE,MAAM,GACT,YAAY,GAAG,SAAS,CAQ1B;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,cAAc,EAClB,IAAI,EAAE,MAAM,GACX,YAAY,GAAG,SAAS,CAK1B;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,cAAc,EAClB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,iBAAiB,GACvB,YAAY,CAsBd;AA6BD,wBAAgB,YAAY,CAAC,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAMjE"}
+{"version":3,"file":"schema-repository.d.ts","sourceRoot":"","sources":["../src/schema-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAOlE,OAAO,KAAK,EAEV,iBAAiB,EAIjB,YAAY,EACZ,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAMrC,wBAAsB,YAAY,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAkBvG;AAED,wBAAsB,WAAW,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAI9E;AAED,wBAAsB,aAAa,CAAC,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAKtG;AAED,wBAAsB,eAAe,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAG1G;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,eAAe,EACnB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,YAAY,CAAC,CAmBvB;AAED,wBAAsB,YAAY,CAAC,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIjF"}

package/dist/schema-repository.js

@@ -2,153 +2,128 @@ import { randomUUID } from "node:crypto";
 import { relationErrors, relationFieldUpdateUnsafe, relationSchemaReferenced, } from "./relation-errors.js";
 import { schemaEntriesUseField } from "./relation-helpers.js";
 const slugPattern = /^[a-z][a-z0-9-]*$/;
-const fieldTypes = [
-    "text",
-    "longText",
-    "number",
-    "boolean",
-    "date",
-    "json",
-    "media",
-    "relation",
-];
-const relationTypes = [
-    "oneToOne",
-    "oneToMany",
-    "manyToOne",
-    "manyToMany",
-];
-export function createSchema(db, input) {
-    validateSchemaInput(db, input);
+const fieldTypes = ["text", "longText", "number", "boolean", "date", "json", "media", "relation"];
+const relationTypes = ["oneToOne", "oneToMany", "manyToOne", "manyToMany"];
+export async function createSchema(db, input) {
+    await validateSchemaInput(db, input);
     const schemaId = randomUUID();
     const now = new Date().toISOString();
     const description = input.description ?? "";
-    const create = db.transaction(() => {
-        db.prepare("INSERT INTO schemas (id, name, slug, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(schemaId, input.name, input.slug, description, now, now);
-        input.fields.forEach((field, index) => insertField(db, schemaId, field, index));
+    await db.transaction(async () => {
+        await db.prepare("INSERT INTO schemas (id, name, slug, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(schemaId, input.name, input.slug, description, now, now);
+        for (const [index, field] of input.fields.entries()) {
+            await insertField(db, schemaId, field, index);
+        }
     });
-    create();
-    const created = getSchemaById(db, schemaId);
-    if (!created) {
+    const created = await getSchemaById(db, schemaId);
+    if (!created)
         throw new Error("SCHEMA_CREATE_FAILED");
-    }
     return created;
 }
-export function listSchemas(db) {
-    const rows = db.prepare("SELECT id FROM schemas ORDER BY created_at ASC").all();
-    return rows.map((row) => getSchemaById(db, row.id)).filter(isSchemaRecord);
+export async function listSchemas(db) {
+    const rows = await db.prepare("SELECT id FROM schemas ORDER BY created_at ASC").all();
+    const schemas = await Promise.all(rows.map((row) => getSchemaById(db, row.id)));
+    return schemas.filter(isSchemaRecord);
 }
-export function getSchemaById(db, id) {
-    const schema = db.prepare("SELECT id, name, slug, description FROM schemas WHERE id = ?").get(id);
-    if (!schema) {
-        return undefined;
-    }
-    return { ...schema, fields: listFields(db, schema.id) };
+export async function getSchemaById(db, id) {
+    const schema = await db
+        .prepare("SELECT id, name, slug, description FROM schemas WHERE id = ?")
+        .get(id);
+    return schema ? { ...schema, fields: await listFields(db, schema.id) } : undefined;
 }
-export function getSchemaBySlug(db, slug) {
-    const row = db.prepare("SELECT id FROM schemas WHERE slug = ?").get(slug);
+export async function getSchemaBySlug(db, slug) {
+    const row = await db.prepare("SELECT id FROM schemas WHERE slug = ?").get(slug);
     return row ? getSchemaById(db, row.id) : undefined;
 }
-export function updateSchema(db, id, input) {
-    if (!getSchemaById(db, id)) {
+export async function updateSchema(db, id, input) {
+    if (!(await getSchemaById(db, id)))
         throw new Error("SCHEMA_NOT_FOUND");
-    }
-    assertSafeRelationUpdate(db, id, input);
-    validateSchemaInput(db, input);
+    await assertSafeRelationUpdate(db, id, input);
+    await validateSchemaInput(db, input);
     const now = new Date().toISOString();
     const description = input.description ?? "";
-    const update = db.transaction(() => {
-        db.prepare("UPDATE schemas SET name = ?, slug = ?, description = ?, updated_at = ? WHERE id = ?").run(input.name, input.slug, description, now, id);
-        db.prepare("DELETE FROM fields WHERE schema_id = ?").run(id);
-        input.fields.forEach((field, index) => insertField(db, id, field, index));
+    await db.transaction(async () => {
+        await db.prepare("UPDATE schemas SET name = ?, slug = ?, description = ?, updated_at = ? WHERE id = ?")
+            .run(input.name, input.slug, description, now, id);
+        await db.prepare("DELETE FROM fields WHERE schema_id = ?").run(id);
+        for (const [index, field] of input.fields.entries()) {
+            await insertField(db, id, field, index);
+        }
     });
-    update();
-    const updated = getSchemaById(db, id);
-    if (!updated) {
+    const updated = await getSchemaById(db, id);
+    if (!updated)
         throw new Error("SCHEMA_UPDATE_FAILED");
-    }
     return updated;
 }
-function assertSafeRelationUpdate(db, schemaId, input) {
-    const current = getSchemaById(db, schemaId);
+export async function deleteSchema(db, id) {
+    await assertSchemaNotReferenced(db, id);
+    const result = await db.prepare("DELETE FROM schemas WHERE id = ?").run(id);
+    if (result.changes === 0)
+        throw new Error("SCHEMA_NOT_FOUND");
+}
+async function assertSafeRelationUpdate(db, schemaId, input) {
+    const current = await getSchemaById(db, schemaId);
     if (!current)
         return;
     const nextBySlug = new Map(input.fields.map((field) => [field.slug, field]));
     for (const currentField of current.fields) {
         if (currentField.type !== "relation")
             continue;
-        if (!schemaEntriesUseField(db, schemaId, currentField.slug))
+        if (!(await schemaEntriesUseField(db, schemaId, currentField.slug)))
             continue;
         const nextField = nextBySlug.get(currentField.slug);
-        if (!nextField || nextField.type !== "relation") {
+        if (!nextField || nextField.type !== "relation")
             throw new Error(relationFieldUpdateUnsafe(currentField.slug));
-        }
         const currentRelationType = currentField.relationType ?? "manyToOne";
         const nextRelationType = nextField.relationType ?? "manyToOne";
-        if (currentField.relationSchemaId !== nextField.relationSchemaId ||
-            currentRelationType !== nextRelationType) {
+        if (currentField.relationSchemaId !== nextField.relationSchemaId || currentRelationType !== nextRelationType) {
             throw new Error(relationFieldUpdateUnsafe(currentField.slug));
         }
     }
 }
-export function deleteSchema(db, id) {
-    assertSchemaNotReferenced(db, id);
-    const result = db.prepare("DELETE FROM schemas WHERE id = ?").run(id);
-    if (result.changes === 0) {
-        throw new Error("SCHEMA_NOT_FOUND");
-    }
-}
-function assertSchemaNotReferenced(db, id) {
-    const dependent = db
+async function assertSchemaNotReferenced(db, id) {
+    const dependent = await db
         .prepare("SELECT schema_id as schemaId FROM fields WHERE relation_schema_id = ? AND schema_id != ? LIMIT 1")
         .get(id, id);
-    if (dependent) {
+    if (dependent)
         throw new Error(relationSchemaReferenced(id));
-    }
 }
-function insertField(db, schemaId, field, position) {
-    db.prepare("INSERT INTO fields (id, schema_id, name, slug, type, relation_schema_id, relation_type, required, position) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(randomUUID(), schemaId, field.name, field.slug, field.type, field.relationSchemaId ?? null, field.relationType ?? null, field.required ? 1 : 0, position);
+async function insertField(db, schemaId, field, position) {
+    await db.prepare("INSERT INTO fields (id, schema_id, name, slug, type, relation_schema_id, relation_type, required, position) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(randomUUID(), schemaId, field.name, field.slug, field.type, field.relationSchemaId ?? null, field.relationType ?? null, field.required ? 1 : 0, position);
 }
-function listFields(db, schemaId) {
-    const rows = db
+async function listFields(db, schemaId) {
+    const rows = await db
         .prepare("SELECT id, schema_id as schemaId, name, slug, type, relation_schema_id as relationSchemaId, relation_type as relationType, required, position FROM fields WHERE schema_id = ? ORDER BY position ASC")
         .all(schemaId);
     return rows.map((row) => ({ ...row, required: Boolean(row.required) }));
 }
-function validateSchemaInput(db, input) {
+async function validateSchemaInput(db, input) {
     validateSlug(input.slug, "SCHEMA_SLUG_INVALID");
-    if (input.fields.length === 0) {
+    if (input.fields.length === 0)
         throw new Error("SCHEMA_FIELDS_REQUIRED");
-    }
     for (const field of input.fields) {
         validateSlug(field.slug, "FIELD_SLUG_INVALID");
-        if (!fieldTypes.includes(field.type)) {
+        if (!fieldTypes.includes(field.type))
             throw new Error("FIELD_TYPE_INVALID");
-        }
-        validateRelationMetadata(db, field);
+        await validateRelationMetadata(db, field);
     }
 }
-function validateRelationMetadata(db, field) {
+async function validateRelationMetadata(db, field) {
     if (field.type !== "relation") {
-        if (field.relationSchemaId || field.relationType) {
+        if (field.relationSchemaId || field.relationType)
             throw new Error(relationErrors.metadataForNonRelationField);
-        }
         return;
     }
-    if (!field.relationSchemaId) {
+    if (!field.relationSchemaId)
         throw new Error(relationErrors.targetRequired);
-    }
-    if (!getSchemaById(db, field.relationSchemaId)) {
+    if (!(await getSchemaById(db, field.relationSchemaId)))
         throw new Error(relationErrors.targetMissing);
-    }
-    if (field.relationType && !relationTypes.includes(field.relationType)) {
+    if (field.relationType && !relationTypes.includes(field.relationType))
         throw new Error(relationErrors.typeInvalid);
-    }
 }
 function validateSlug(slug, error) {
-    if (!slugPattern.test(slug)) {
+    if (!slugPattern.test(slug))
         throw new Error(error);
-    }
 }
 function isSchemaRecord(value) {
     return Boolean(value);

package/dist/sqlite-adapter.d.ts

@@ -0,0 +1,15 @@
+import type { ApiagexDatabase, DatabaseStatement } from "./database-adapter.type.js";
+import { type SqliteDatabase } from "./sqlite.js";
+export declare class SqliteApiagexDatabase implements ApiagexDatabase {
+    private readonly db;
+    readonly provider = "sqlite";
+    constructor(db: SqliteDatabase);
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): DatabaseStatement;
+    transaction<TResult>(callback: () => Promise<TResult>): Promise<TResult>;
+    close(): Promise<void>;
+}
+export declare function openSqliteAdapter(path?: string): ApiagexDatabase;
+export declare function openMigratedSqliteAdapter(path?: string): ApiagexDatabase;
+export declare function wrapSqliteDatabase(db: SqliteDatabase): ApiagexDatabase;
+//# sourceMappingURL=sqlite-adapter.d.ts.map

package/dist/sqlite-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-adapter.d.ts","sourceRoot":"","sources":["../src/sqlite-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAyC,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC5H,OAAO,EAA0C,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAE1F,qBAAa,qBAAsB,YAAW,eAAe;IAG/C,OAAO,CAAC,QAAQ,CAAC,EAAE;IAF/B,QAAQ,CAAC,QAAQ,YAAY;gBAEA,EAAE,EAAE,cAAc;IAEzC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB;IASjC,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAYxE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B;AAED,wBAAgB,iBAAiB,CAAC,IAAI,SAAa,GAAG,eAAe,CAEpE;AAED,wBAAgB,yBAAyB,CAAC,IAAI,SAAa,GAAG,eAAe,CAI5E;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,cAAc,GAAG,eAAe,CAEtE"}

package/dist/sqlite-adapter.js

@@ -0,0 +1,48 @@
+import { migrateMvpDatabase, openSqliteDatabase } from "./sqlite.js";
+export class SqliteApiagexDatabase {
+    db;
+    provider = "sqlite";
+    constructor(db) {
+        this.db = db;
+    }
+    async exec(sql) {
+        this.db.exec(sql);
+    }
+    prepare(sql) {
+        const statement = this.db.prepare(sql);
+        return {
+            get: async (...params) => statement.get(...params),
+            all: async (...params) => statement.all(...params),
+            run: async (...params) => toRunResult(statement.run(...params)),
+        };
+    }
+    async transaction(callback) {
+        this.db.exec("BEGIN");
+        try {
+            const result = await callback();
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    async close() {
+        this.db.close();
+    }
+}
+export function openSqliteAdapter(path = ":memory:") {
+    return new SqliteApiagexDatabase(openSqliteDatabase(path));
+}
+export function openMigratedSqliteAdapter(path = ":memory:") {
+    const db = openSqliteDatabase(path);
+    migrateMvpDatabase(db);
+    return new SqliteApiagexDatabase(db);
+}
+export function wrapSqliteDatabase(db) {
+    return new SqliteApiagexDatabase(db);
+}
+function toRunResult(result) {
+    return { changes: result.changes };
+}