@apiagex/database 0.6.2

package/dist/relation-errors.d.ts

@@ -0,0 +1,20 @@
+export declare const relationErrors: {
+    readonly metadataForNonRelationField: "RELATION_METADATA_FOR_NON_RELATION_FIELD";
+    readonly entryReferenced: "RELATION_ENTRY_REFERENCED";
+    readonly fieldUpdateUnsafe: "RELATION_FIELD_UPDATE_UNSAFE";
+    readonly oneToOneConflict: "RELATION_ONE_TO_ONE_CONFLICT";
+    readonly schemaReferenced: "RELATION_SCHEMA_REFERENCED";
+    readonly targetEntryInvalid: "RELATION_TARGET_ENTRY_INVALID";
+    readonly targetMissing: "RELATION_TARGET_MISSING";
+    readonly targetRequired: "RELATION_TARGET_REQUIRED";
+    readonly typeInvalid: "RELATION_TYPE_INVALID";
+    readonly valueShapeInvalid: "RELATION_VALUE_SHAPE_INVALID";
+};
+export type RelationErrorCode = (typeof relationErrors)[keyof typeof relationErrors];
+export declare function relationEntryReferenced(entryId: string): string;
+export declare function relationFieldUpdateUnsafe(fieldSlug: string): string;
+export declare function relationSchemaReferenced(schemaId: string): string;
+export declare function relationTargetEntryInvalid(fieldSlug: string): string;
+export declare function relationOneToOneConflict(fieldSlug: string): string;
+export declare function relationValueShapeInvalid(fieldSlug: string): string;
+//# sourceMappingURL=relation-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relation-errors.d.ts","sourceRoot":"","sources":["../src/relation-errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;;;;;;CAWjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAErF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/relation-errors.js

@@ -0,0 +1,30 @@
+export const relationErrors = {
+    metadataForNonRelationField: "RELATION_METADATA_FOR_NON_RELATION_FIELD",
+    entryReferenced: "RELATION_ENTRY_REFERENCED",
+    fieldUpdateUnsafe: "RELATION_FIELD_UPDATE_UNSAFE",
+    oneToOneConflict: "RELATION_ONE_TO_ONE_CONFLICT",
+    schemaReferenced: "RELATION_SCHEMA_REFERENCED",
+    targetEntryInvalid: "RELATION_TARGET_ENTRY_INVALID",
+    targetMissing: "RELATION_TARGET_MISSING",
+    targetRequired: "RELATION_TARGET_REQUIRED",
+    typeInvalid: "RELATION_TYPE_INVALID",
+    valueShapeInvalid: "RELATION_VALUE_SHAPE_INVALID",
+};
+export function relationEntryReferenced(entryId) {
+    return `${relationErrors.entryReferenced}:${entryId}`;
+}
+export function relationFieldUpdateUnsafe(fieldSlug) {
+    return `${relationErrors.fieldUpdateUnsafe}:${fieldSlug}`;
+}
+export function relationSchemaReferenced(schemaId) {
+    return `${relationErrors.schemaReferenced}:${schemaId}`;
+}
+export function relationTargetEntryInvalid(fieldSlug) {
+    return `${relationErrors.targetEntryInvalid}:${fieldSlug}`;
+}
+export function relationOneToOneConflict(fieldSlug) {
+    return `${relationErrors.oneToOneConflict}:${fieldSlug}`;
+}
+export function relationValueShapeInvalid(fieldSlug) {
+    return `${relationErrors.valueShapeInvalid}:${fieldSlug}`;
+}

package/dist/relation-helpers.d.ts

@@ -0,0 +1,14 @@
+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 parseEntryData(dataJson: string): EntryData;
+export declare function schemaEntriesUseField(db: SqliteDatabase, schemaId: string, fieldSlug: string): boolean;
+export {};
+//# sourceMappingURL=relation-helpers.d.ts.map

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

@@ -0,0 +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"}

package/dist/relation-helpers.js

@@ -0,0 +1,21 @@
+export function relationTypeOf(field) {
+    return field.relationType ?? "manyToOne";
+}
+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 function parseEntryData(dataJson) {
+    return JSON.parse(dataJson);
+}
+export function schemaEntriesUseField(db, schemaId, fieldSlug) {
+    const rows = 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

@@ -0,0 +1,8 @@
+import type { SqliteDatabase } from "./sqlite.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;
+//# sourceMappingURL=role-repository.d.ts.map

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

@@ -0,0 +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"}

package/dist/role-repository.js

@@ -0,0 +1,66 @@
+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) {
+    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);
+    return requireRole(db, id);
+}
+export 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);
+    return requireRole(db, id);
+}
+export function listRoles(db) {
+    const rows = db
+        .prepare(roleSelectSql("WHERE role_kind = 'api' ORDER BY created_at ASC"))
+        .all();
+    return rows.map(rowToRole);
+}
+export function listAdminRoles(db) {
+    const rows = 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);
+    return row ? rowToRole(row) : undefined;
+}
+function validateApiRole(input) {
+    validateRoleName(input);
+    if (input.name === "owner") {
+        throw new Error("ROLE_OWNER_RESERVED");
+    }
+    if (adminRoleNames.has(input.name)) {
+        throw new Error("ROLE_ADMIN_RESERVED");
+    }
+}
+function validateAdminRole(input) {
+    validateRoleName(input);
+    if (input.name === "owner") {
+        throw new Error("ROLE_OWNER_RESERVED");
+    }
+}
+function validateRoleName(input) {
+    if (!roleNamePattern.test(input.name)) {
+        throw new Error("ROLE_NAME_INVALID");
+    }
+}
+function requireRole(db, id) {
+    const role = getRoleById(db, id);
+    if (!role) {
+        throw new Error("ROLE_NOT_FOUND");
+    }
+    return role;
+}
+function rowToRole(row) {
+    return { ...row, isOwner: Boolean(row.isOwner) };
+}
+function roleSelectSql(suffix) {
+    return `SELECT id, name, description, is_owner as isOwner, role_kind as roleKind, created_at as createdAt, updated_at as updatedAt FROM roles ${suffix}`;
+}

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

@@ -0,0 +1,15 @@
+export type RoleKind = "admin" | "api";
+export type CreateRoleInput = {
+    name: string;
+    description?: string;
+};
+export type RoleRecord = {
+    id: string;
+    name: string;
+    description: string;
+    isOwner: boolean;
+    roleKind: RoleKind;
+    createdAt: string;
+    updatedAt: string;
+};
+//# sourceMappingURL=role-repository.type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"role-repository.type.d.ts","sourceRoot":"","sources":["../src/role-repository.type.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAC;AAEvC,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/role-repository.type.js

@@ -0,0 +1 @@
+export {};

package/dist/schema-repository.d.ts

@@ -0,0 +1,9 @@
+import type { SqliteDatabase } from "./sqlite.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;
+//# sourceMappingURL=schema-repository.d.ts.map

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

@@ -0,0 +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"}

package/dist/schema-repository.js

@@ -0,0 +1,155 @@
+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 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));
+    });
+    create();
+    const created = 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 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 function getSchemaBySlug(db, slug) {
+    const row = 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)) {
+        throw new Error("SCHEMA_NOT_FOUND");
+    }
+    assertSafeRelationUpdate(db, id, input);
+    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));
+    });
+    update();
+    const updated = getSchemaById(db, id);
+    if (!updated) {
+        throw new Error("SCHEMA_UPDATE_FAILED");
+    }
+    return updated;
+}
+function assertSafeRelationUpdate(db, schemaId, input) {
+    const current = 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))
+            continue;
+        const nextField = nextBySlug.get(currentField.slug);
+        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) {
+            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
+        .prepare("SELECT schema_id as schemaId FROM fields WHERE relation_schema_id = ? AND schema_id != ? LIMIT 1")
+        .get(id, id);
+    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);
+}
+function listFields(db, schemaId) {
+    const rows = 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) {
+    validateSlug(input.slug, "SCHEMA_SLUG_INVALID");
+    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)) {
+            throw new Error("FIELD_TYPE_INVALID");
+        }
+        validateRelationMetadata(db, field);
+    }
+}
+function validateRelationMetadata(db, field) {
+    if (field.type !== "relation") {
+        if (field.relationSchemaId || field.relationType) {
+            throw new Error(relationErrors.metadataForNonRelationField);
+        }
+        return;
+    }
+    if (!field.relationSchemaId) {
+        throw new Error(relationErrors.targetRequired);
+    }
+    if (!getSchemaById(db, field.relationSchemaId)) {
+        throw new Error(relationErrors.targetMissing);
+    }
+    if (field.relationType && !relationTypes.includes(field.relationType)) {
+        throw new Error(relationErrors.typeInvalid);
+    }
+}
+function validateSlug(slug, error) {
+    if (!slugPattern.test(slug)) {
+        throw new Error(error);
+    }
+}
+function isSchemaRecord(value) {
+    return Boolean(value);
+}

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

@@ -0,0 +1,45 @@
+export type FieldType = "text" | "longText" | "number" | "boolean" | "date" | "json" | "media" | "relation";
+export type RelationType = "oneToOne" | "oneToMany" | "manyToOne" | "manyToMany";
+export type SingleRelationValue = string | null;
+export type MultiRelationValue = string[];
+export type RelationValue = SingleRelationValue | MultiRelationValue;
+export type RelationFieldContract = {
+    relationSchemaId: string;
+    relationType: RelationType;
+    required: boolean;
+    valueShape: "single" | "multi";
+};
+export type CreateFieldInput = {
+    name: string;
+    slug: string;
+    type: FieldType;
+    required?: boolean;
+    relationSchemaId?: string;
+    relationType?: RelationType;
+};
+export type CreateSchemaInput = {
+    name: string;
+    slug: string;
+    description?: string;
+    fields: CreateFieldInput[];
+};
+export type UpdateSchemaInput = CreateSchemaInput;
+export type FieldRecord = {
+    id: string;
+    schemaId: string;
+    name: string;
+    slug: string;
+    type: FieldType;
+    required: boolean;
+    relationSchemaId?: string | null;
+    relationType?: RelationType | null;
+    position: number;
+};
+export type SchemaRecord = {
+    id: string;
+    name: string;
+    slug: string;
+    description: string;
+    fields: FieldRecord[];
+};
+//# sourceMappingURL=schema-repository.type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-repository.type.d.ts","sourceRoot":"","sources":["../src/schema-repository.type.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,UAAU,GACV,QAAQ,GACR,SAAS,GACT,MAAM,GACN,MAAM,GACN,OAAO,GACP,UAAU,CAAC;AAEf,MAAM,MAAM,YAAY,GACpB,UAAU,GACV,WAAW,GACX,WAAW,GACX,YAAY,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,IAAI,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAAG,MAAM,EAAE,CAAC;AAE1C,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,kBAAkB,CAAC;AAErE,MAAM,MAAM,qBAAqB,GAAG;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,QAAQ,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC;AAElD,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAAC"}

package/dist/schema-repository.type.js

@@ -0,0 +1 @@
+export {};

package/dist/schema.type.d.ts

@@ -0,0 +1,9 @@
+export type MvpTableName = "roles" | "users" | "schemas" | "fields" | "entries" | "permissions" | "admin_permissions" | "api_tokens" | "webhooks" | "webhook_events" | "webhook_deliveries" | "realtime_configs" | "realtime_events" | "realtime_sessions" | "migrations";
+export type MigrationRecord = {
+    id: string;
+    applied_at: string;
+};
+export type TableInfoRow = {
+    name: string;
+};
+//# sourceMappingURL=schema.type.d.ts.map

package/dist/schema.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.type.d.ts","sourceRoot":"","sources":["../src/schema.type.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GACpB,OAAO,GACP,OAAO,GACP,SAAS,GACT,QAAQ,GACR,SAAS,GACT,aAAa,GACb,mBAAmB,GACnB,YAAY,GACZ,UAAU,GACV,gBAAgB,GAChB,oBAAoB,GACpB,kBAAkB,GAClB,iBAAiB,GACjB,mBAAmB,GACnB,YAAY,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}

package/dist/schema.type.js

@@ -0,0 +1 @@
+export {};

package/dist/sqlite.d.ts

@@ -0,0 +1,6 @@
+import Database from "better-sqlite3";
+export type SqliteDatabase = Database.Database;
+export declare function openSqliteDatabase(path?: string): SqliteDatabase;
+export declare function migrateMvpDatabase(db: SqliteDatabase): void;
+export declare function listMvpTables(db: SqliteDatabase): string[];
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAStC,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,QAAQ,CAAC;AAE/C,wBAAgB,kBAAkB,CAAC,IAAI,SAAa,GAAG,cAAc,CAIpE;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAa3D;AAkBD,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM,EAAE,CAQ1D"}

package/dist/sqlite.js

@@ -0,0 +1,40 @@
+import Database from "better-sqlite3";
+import { MVP_ADDITIVE_MIGRATIONS_SQL, MVP_FOUNDATION_SQL, MVP_MIGRATION_ID, MVP_TABLES, } from "./migrations.js";
+export function openSqliteDatabase(path = ":memory:") {
+    const db = new Database(path);
+    db.pragma("foreign_keys = ON");
+    return db;
+}
+export function migrateMvpDatabase(db) {
+    db.exec(MVP_FOUNDATION_SQL);
+    applyAdditiveMigrations(db);
+    const existing = db
+        .prepare("SELECT id, applied_at FROM migrations WHERE id = ?")
+        .get(MVP_MIGRATION_ID);
+    if (!existing) {
+        db.prepare("INSERT INTO migrations (id, applied_at) VALUES (?, ?)").run(MVP_MIGRATION_ID, new Date().toISOString());
+    }
+}
+function applyAdditiveMigrations(db) {
+    for (const sql of MVP_ADDITIVE_MIGRATIONS_SQL) {
+        try {
+            db.exec(sql);
+        }
+        catch (error) {
+            if (!isDuplicateColumnError(error)) {
+                throw error;
+            }
+        }
+    }
+}
+function isDuplicateColumnError(error) {
+    return error instanceof Error && error.message.includes("duplicate column name");
+}
+export function listMvpTables(db) {
+    const rows = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
+        .all();
+    return rows
+        .map((row) => row.name)
+        .filter((name) => MVP_TABLES.includes(name));
+}

package/dist/user-repository.d.ts

@@ -0,0 +1,11 @@
+import type { SqliteDatabase } from "./sqlite.js";
+import type { CreateUserInput, UserRecord } from "./user-repository.type.js";
+export declare function createUser(db: SqliteDatabase, input: CreateUserInput): UserRecord;
+export declare function listUsers(db: SqliteDatabase): UserRecord[];
+export declare function getUserById(db: SqliteDatabase, id: string): UserRecord | undefined;
+export declare function getUserPasswordHashByEmail(db: SqliteDatabase, email: string): {
+    id: string;
+    passwordHash: string;
+    roleId: string;
+} | undefined;
+//# sourceMappingURL=user-repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-repository.d.ts","sourceRoot":"","sources":["../src/user-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAI7E,wBAAgB,UAAU,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CASjF;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,cAAc,GAAG,UAAU,EAAE,CAK1D;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAIlF;AAED,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,MAAM,GACZ;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQlE"}

package/dist/user-repository.js

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import { getRoleById } from "./role-repository.js";
+export function createUser(db, input) {
+    const email = normalizeEmail(input.email);
+    validateUser(db, { ...input, email });
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare("INSERT INTO users (id, email, password_hash, role_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(id, email, input.passwordHash, input.roleId, now, now);
+    return requireUser(db, id);
+}
+export function listUsers(db) {
+    const rows = db
+        .prepare(userSelectSql("WHERE roles.role_kind = 'api' ORDER BY users.created_at ASC"))
+        .all();
+    return rows;
+}
+export function getUserById(db, id) {
+    return db
+        .prepare(userSelectSql("WHERE users.id = ? AND roles.role_kind = 'api'"))
+        .get(id);
+}
+export function getUserPasswordHashByEmail(db, email) {
+    return db
+        .prepare(`SELECT users.id, users.password_hash as passwordHash, users.role_id as roleId
+       FROM users JOIN roles ON roles.id = users.role_id
+       WHERE users.email = ? AND roles.role_kind = 'api'`)
+        .get(normalizeEmail(email));
+}
+function validateUser(db, input) {
+    if (!input.email.includes("@")) {
+        throw new Error("USER_EMAIL_INVALID");
+    }
+    if (!input.passwordHash) {
+        throw new Error("USER_PASSWORD_HASH_REQUIRED");
+    }
+    const role = getRoleById(db, input.roleId);
+    if (!role) {
+        throw new Error("ROLE_NOT_FOUND");
+    }
+    if (role.roleKind !== "api") {
+        throw new Error("ROLE_API_REQUIRED");
+    }
+}
+function requireUser(db, id) {
+    const user = getUserById(db, id);
+    if (!user) {
+        throw new Error("USER_NOT_FOUND");
+    }
+    return user;
+}
+function normalizeEmail(email) {
+    return email.trim().toLowerCase();
+}
+function userSelectSql(suffix) {
+    return `SELECT users.id, users.email, users.role_id as roleId, roles.name as roleName, roles.role_kind as roleKind, users.created_at as createdAt, users.updated_at as updatedAt FROM users JOIN roles ON roles.id = users.role_id ${suffix}`;
+}

package/dist/user-repository.type.d.ts

@@ -0,0 +1,15 @@
+export type CreateUserInput = {
+    email: string;
+    passwordHash: string;
+    roleId: string;
+};
+export type UserRecord = {
+    id: string;
+    email: string;
+    roleId: string;
+    roleName: string;
+    roleKind: "api";
+    createdAt: string;
+    updatedAt: string;
+};
+//# sourceMappingURL=user-repository.type.d.ts.map

package/dist/user-repository.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-repository.type.d.ts","sourceRoot":"","sources":["../src/user-repository.type.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/user-repository.type.js

@@ -0,0 +1 @@
+export {};

package/dist/webhook-repository.d.ts

@@ -0,0 +1,15 @@
+import type { SqliteDatabase } from "./sqlite.js";
+import type { EnqueueWebhookEventInput, RecordWebhookDeliveryInput, WebhookDeliveryRecord, WebhookDraft, WebhookEventRecord, WebhookEventStatus, WebhookRecord, WebhookSecretRecord } from "./webhook-repository.type.js";
+export declare function createWebhook(db: SqliteDatabase, input: WebhookDraft): WebhookRecord;
+export declare function updateWebhook(db: SqliteDatabase, webhookId: string, input: WebhookDraft): WebhookRecord;
+export declare function listWebhooks(db: SqliteDatabase): WebhookRecord[];
+export declare function deleteWebhook(db: SqliteDatabase, webhookId: string): boolean;
+export declare function enqueueWebhookEvent(db: SqliteDatabase, input: EnqueueWebhookEventInput): WebhookEventRecord;
+export declare function listPendingWebhookEvents(db: SqliteDatabase, now?: string, limit?: number): WebhookEventRecord[];
+export declare function listMatchingWebhooks(db: SqliteDatabase, event: WebhookEventRecord): WebhookSecretRecord[];
+export declare function listWebhookDeliveries(db: SqliteDatabase, webhookId?: string): WebhookDeliveryRecord[];
+export declare function countWebhookDeliveryAttempts(db: SqliteDatabase, eventId: string, webhookId: string): number;
+export declare function hasSuccessfulWebhookDelivery(db: SqliteDatabase, eventId: string, webhookId: string): boolean;
+export declare function recordWebhookDelivery(db: SqliteDatabase, input: RecordWebhookDeliveryInput): WebhookDeliveryRecord;
+export declare function updateWebhookEventStatus(db: SqliteDatabase, eventId: string, status: WebhookEventStatus, attempts: number, nextRetryAt: string | null): void;
+//# sourceMappingURL=webhook-repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-repository.d.ts","sourceRoot":"","sources":["../src/webhook-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC1B,qBAAqB,EACrB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAElB,aAAa,EACb,mBAAmB,EAEpB,MAAM,8BAA8B,CAAC;AAgBtC,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,GAAG,aAAa,CASpF;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,aAAa,CASvG;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,cAAc,GAAG,aAAa,EAAE,CAGhE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAG5E;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,wBAAwB,GAAG,kBAAkB,CAe3G;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,cAAc,EAAE,GAAG,SAA2B,EAAE,KAAK,SAAK,GAAG,kBAAkB,EAAE,CAI7H;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,EAAE,CAIzG;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAMrG;AAED,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAI3G;AAED,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAI5G;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,0BAA0B,GAAG,qBAAqB,CASlH;AAED,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,cAAc,EAClB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,IAAI,CAGN"}