or3-provider-sqlite 0.0.1

package/dist/runtime/server/db/migrations/003_sync_hardening.js

@@ -0,0 +1,67 @@
+import { sql } from "kysely";
+const SYNCED_TABLES = [
+  "s_threads",
+  "s_messages",
+  "s_projects",
+  "s_posts",
+  "s_kv",
+  "s_file_meta",
+  "s_notifications"
+];
+async function rebuildSyncedTable(db, tableName) {
+  const nextTable = `${tableName}__new`;
+  await sql.raw(`DROP TABLE IF EXISTS "${nextTable}"`).execute(db);
+  await sql.raw(`
+        CREATE TABLE "${nextTable}" (
+            id TEXT NOT NULL,
+            workspace_id TEXT NOT NULL,
+            data_json TEXT NOT NULL,
+            clock INTEGER NOT NULL DEFAULT 0,
+            hlc TEXT NOT NULL DEFAULT '',
+            device_id TEXT NOT NULL DEFAULT '',
+            deleted INTEGER NOT NULL DEFAULT 0,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            PRIMARY KEY (workspace_id, id)
+        )
+    `).execute(db);
+  await sql.raw(`
+        INSERT INTO "${nextTable}" (
+            id, workspace_id, data_json, clock, hlc, device_id, deleted, created_at, updated_at
+        )
+        SELECT id, workspace_id, data_json, clock, hlc, device_id, deleted, created_at, updated_at
+        FROM "${tableName}"
+    `).execute(db);
+  await sql.raw(`DROP TABLE "${tableName}"`).execute(db);
+  await sql.raw(`ALTER TABLE "${nextTable}" RENAME TO "${tableName}"`).execute(db);
+  await sql.raw(
+    `CREATE INDEX IF NOT EXISTS "idx_${tableName}_ws" ON "${tableName}" (workspace_id)`
+  ).execute(db);
+}
+export async function up(db) {
+  await sql.raw(`
+        DELETE FROM tombstones
+        WHERE rowid IN (
+            SELECT rowid
+            FROM (
+                SELECT
+                    rowid,
+                    ROW_NUMBER() OVER (
+                        PARTITION BY workspace_id, table_name, pk
+                        ORDER BY clock DESC, server_version DESC, created_at DESC, rowid DESC
+                    ) AS rn
+                FROM tombstones
+            ) ranked
+            WHERE rn > 1
+        )
+    `).execute(db);
+  await sql.raw(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_tombstones_ws_table_pk
+        ON tombstones(workspace_id, table_name, pk)
+    `).execute(db);
+  for (const tableName of SYNCED_TABLES) {
+    await rebuildSyncedTable(db, tableName);
+  }
+}
+export async function down(_db) {
+}

package/dist/runtime/server/db/migrations/004_auth_invites.d.ts

@@ -0,0 +1,3 @@
+import type { Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/004_auth_invites.js

@@ -0,0 +1,18 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await db.schema.createTable("auth_invites").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("workspace_id", "text", (col) => col.notNull()).addColumn("email", "text", (col) => col.notNull()).addColumn("role", "text", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull().defaultTo("pending")).addColumn("invited_by_user_id", "text", (col) => col.notNull()).addColumn("token_hash", "text", (col) => col.notNull()).addColumn("expires_at", "integer", (col) => col.notNull()).addColumn("accepted_at", "integer").addColumn("accepted_user_id", "text").addColumn("revoked_at", "integer").addColumn(
+    "created_at",
+    "integer",
+    (col) => col.notNull().defaultTo(sql`(unixepoch())`)
+  ).addColumn(
+    "updated_at",
+    "integer",
+    (col) => col.notNull().defaultTo(sql`(unixepoch())`)
+  ).execute();
+  await db.schema.createIndex("idx_auth_invites_ws_status_exp").ifNotExists().on("auth_invites").columns(["workspace_id", "status", "expires_at"]).execute();
+  await db.schema.createIndex("idx_auth_invites_ws_email_status").ifNotExists().on("auth_invites").columns(["workspace_id", "email", "status"]).execute();
+  await db.schema.createIndex("idx_auth_invites_ws_token").ifNotExists().on("auth_invites").columns(["workspace_id", "token_hash"]).execute();
+}
+export async function down(db) {
+  await db.schema.dropTable("auth_invites").ifExists().execute();
+}

package/dist/runtime/server/db/migrations/005_admin_stores.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Migration 005: Admin store support tables.
+ */
+import type { Kysely } from 'kysely';
+import type { Or3SqliteDb } from '../schema.js';
+export declare function up(db: Kysely<Or3SqliteDb>): Promise<void>;
+export declare function down(db: Kysely<Or3SqliteDb>): Promise<void>;

package/dist/runtime/server/db/migrations/005_admin_stores.js

@@ -0,0 +1,12 @@
+export async function up(db) {
+  await db.schema.createTable("admin_users").ifNotExists().addColumn("user_id", "text", (col) => col.notNull().primaryKey()).addColumn("created_at", "integer", (col) => col.notNull()).addColumn("created_by_user_id", "text").execute();
+  await db.schema.createTable("admin_workspace_settings").ifNotExists().addColumn("id", "text", (col) => col.notNull().primaryKey()).addColumn("workspace_id", "text", (col) => col.notNull()).addColumn("key", "text", (col) => col.notNull()).addColumn("value", "text", (col) => col.notNull()).addColumn("updated_at", "integer", (col) => col.notNull()).execute();
+  await db.schema.createIndex("idx_admin_workspace_settings_workspace_key").ifNotExists().on("admin_workspace_settings").columns(["workspace_id", "key"]).unique().execute();
+  await db.schema.createIndex("idx_admin_workspace_settings_workspace").ifNotExists().on("admin_workspace_settings").column("workspace_id").execute();
+}
+export async function down(db) {
+  await db.schema.dropIndex("idx_admin_workspace_settings_workspace").ifExists().execute();
+  await db.schema.dropIndex("idx_admin_workspace_settings_workspace_key").ifExists().execute();
+  await db.schema.dropTable("admin_workspace_settings").ifExists().execute();
+  await db.schema.dropTable("admin_users").ifExists().execute();
+}

package/dist/runtime/server/db/schema.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Database schema types for the SQLite provider.
+ * All tables use snake_case aligned with sync wire format.
+ */
+import type { Generated, Insertable, Selectable } from 'kysely';
+export interface UsersTable {
+    id: string;
+    email: string | null;
+    display_name: string | null;
+    active_workspace_id: string | null;
+    created_at: Generated<number>;
+}
+export interface AuthAccountsTable {
+    id: string;
+    user_id: string;
+    provider: string;
+    provider_user_id: string;
+    created_at: Generated<number>;
+}
+export interface WorkspacesTable {
+    id: string;
+    name: string;
+    description: string | null;
+    owner_user_id: string;
+    created_at: Generated<number>;
+    deleted: Generated<number>;
+    deleted_at: number | null;
+}
+export interface WorkspaceMembersTable {
+    id: string;
+    workspace_id: string;
+    user_id: string;
+    role: string;
+    created_at: Generated<number>;
+}
+export interface AuthInvitesTable {
+    id: string;
+    workspace_id: string;
+    email: string;
+    role: string;
+    status: string;
+    invited_by_user_id: string;
+    token_hash: string;
+    expires_at: number;
+    accepted_at: number | null;
+    accepted_user_id: string | null;
+    revoked_at: number | null;
+    created_at: Generated<number>;
+    updated_at: Generated<number>;
+}
+export interface ServerVersionCounterTable {
+    workspace_id: string;
+    value: Generated<number>;
+}
+export interface ChangeLogTable {
+    id: string;
+    workspace_id: string;
+    server_version: number;
+    table_name: string;
+    pk: string;
+    op: string;
+    payload_json: string | null;
+    clock: number;
+    hlc: string;
+    device_id: string;
+    op_id: string;
+    created_at: Generated<number>;
+}
+export interface DeviceCursorsTable {
+    id: string;
+    workspace_id: string;
+    device_id: string;
+    last_seen_version: number;
+    updated_at: Generated<number>;
+}
+export interface TombstonesTable {
+    id: string;
+    workspace_id: string;
+    table_name: string;
+    pk: string;
+    deleted_at: number;
+    clock: number;
+    server_version: number;
+    created_at: Generated<number>;
+}
+export interface SyncedEntityTable {
+    id: string;
+    workspace_id: string;
+    data_json: string;
+    clock: number;
+    hlc: string;
+    device_id: string;
+    deleted: Generated<number>;
+    created_at: Generated<number>;
+    updated_at: Generated<number>;
+}
+export interface AdminUsersTable {
+    user_id: string;
+    created_at: number;
+    created_by_user_id: string | null;
+}
+export interface AdminWorkspaceSettingsTable {
+    id: string;
+    workspace_id: string;
+    key: string;
+    value: string;
+    updated_at: number;
+}
+export interface Or3SqliteDb {
+    users: UsersTable;
+    auth_accounts: AuthAccountsTable;
+    workspaces: WorkspacesTable;
+    workspace_members: WorkspaceMembersTable;
+    auth_invites: AuthInvitesTable;
+    server_version_counter: ServerVersionCounterTable;
+    change_log: ChangeLogTable;
+    device_cursors: DeviceCursorsTable;
+    tombstones: TombstonesTable;
+    s_threads: SyncedEntityTable;
+    s_messages: SyncedEntityTable;
+    s_projects: SyncedEntityTable;
+    s_posts: SyncedEntityTable;
+    s_kv: SyncedEntityTable;
+    s_file_meta: SyncedEntityTable;
+    s_notifications: SyncedEntityTable;
+    admin_users: AdminUsersTable;
+    admin_workspace_settings: AdminWorkspaceSettingsTable;
+}
+export type User = Selectable<UsersTable>;
+export type NewUser = Insertable<UsersTable>;
+export type AuthAccount = Selectable<AuthAccountsTable>;
+export type Workspace = Selectable<WorkspacesTable>;
+export type WorkspaceMember = Selectable<WorkspaceMembersTable>;
+export type ChangeLogRow = Selectable<ChangeLogTable>;
+/** Map sync table name -> materialized table name */
+export declare const SYNCED_TABLE_MAP: Record<string, keyof Or3SqliteDb>;
+/** List of allowed sync table names */
+export declare const ALLOWED_SYNC_TABLES: string[];

package/dist/runtime/server/db/schema.js

@@ -0,0 +1,10 @@
+export const SYNCED_TABLE_MAP = {
+  threads: "s_threads",
+  messages: "s_messages",
+  projects: "s_projects",
+  posts: "s_posts",
+  kv: "s_kv",
+  file_meta: "s_file_meta",
+  notifications: "s_notifications"
+};
+export const ALLOWED_SYNC_TABLES = Object.keys(SYNCED_TABLE_MAP);

package/dist/runtime/server/plugins/register.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/register.js

@@ -0,0 +1,48 @@
+import { registerAuthWorkspaceStore } from "~~/server/auth/store/registry";
+import { registerProviderAdminAdapter } from "~~/server/admin/providers/registry";
+import { registerAdminStoreProvider } from "~~/server/admin/stores/registry";
+import { registerSyncGatewayAdapter } from "~~/server/sync/gateway/registry";
+import { createSqliteAuthWorkspaceStore } from "../auth/sqlite-auth-workspace-store.js";
+import { createSqliteSyncGatewayAdapter } from "../sync/sqlite-sync-gateway-adapter.js";
+import {
+  createSqliteAdminUserStore,
+  createSqliteWorkspaceAccessStore,
+  createSqliteWorkspaceSettingsStore
+} from "../admin/stores/sqlite-store.js";
+import { sqliteSyncAdminAdapter } from "../admin/adapters/sync-sqlite.js";
+import { getSqliteDb } from "../db/kysely.js";
+import { runMigrations } from "../db/migrate.js";
+import { useRuntimeConfig } from "#imports";
+const SQLITE_PROVIDER_ID = "sqlite";
+export default defineNitroPlugin(async () => {
+  const config = useRuntimeConfig();
+  if (!config.auth?.enabled) return;
+  if (!config.sync?.enabled) return;
+  if (config.sync?.provider !== SQLITE_PROVIDER_ID) return;
+  const db = getSqliteDb();
+  await runMigrations(db);
+  registerAuthWorkspaceStore({
+    id: SQLITE_PROVIDER_ID,
+    order: 100,
+    create: createSqliteAuthWorkspaceStore
+  });
+  registerSyncGatewayAdapter({
+    id: SQLITE_PROVIDER_ID,
+    order: 100,
+    create: createSqliteSyncGatewayAdapter
+  });
+  registerAdminStoreProvider({
+    id: SQLITE_PROVIDER_ID,
+    createWorkspaceAccessStore: createSqliteWorkspaceAccessStore,
+    createWorkspaceSettingsStore: createSqliteWorkspaceSettingsStore,
+    createAdminUserStore: createSqliteAdminUserStore,
+    getCapabilities: () => ({
+      supportsServerSideAdmin: true,
+      supportsUserSearch: true,
+      supportsWorkspaceList: true,
+      supportsWorkspaceManagement: true,
+      supportsDeploymentAdminGrants: true
+    })
+  });
+  registerProviderAdminAdapter(sqliteSyncAdminAdapter);
+});

package/dist/runtime/server/sync/sqlite-sync-gateway-adapter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SQLite implementation of SyncGatewayAdapter.
+ *
+ * Handles push/pull/updateCursor/gc using Kysely + better-sqlite3.
+ * Uses raw DB transactions via better-sqlite3 for push atomicity
+ * (BEGIN IMMEDIATE prevents concurrent server_version races).
+ */
+import type { H3Event } from 'h3';
+import type { SyncGatewayAdapter } from '~~/server/sync/gateway/types';
+import type { PullRequest, PullResponse, PushBatch, PushResult } from '~~/shared/sync/types';
+export declare class SqliteSyncGatewayAdapter implements SyncGatewayAdapter {
+    id: string;
+    private get db();
+    push(event: H3Event, input: PushBatch): Promise<PushResult>;
+    pull(event: H3Event, input: PullRequest): Promise<PullResponse>;
+    updateCursor(event: H3Event, input: {
+        scope: {
+            workspaceId: string;
+        };
+        deviceId: string;
+        version: number;
+    }): Promise<void>;
+    gcTombstones(event: H3Event, input: {
+        scope: {
+            workspaceId: string;
+        };
+        retentionSeconds: number;
+    }): Promise<void>;
+    gcChangeLog(event: H3Event, input: {
+        scope: {
+            workspaceId: string;
+        };
+        retentionSeconds: number;
+    }): Promise<void>;
+}
+export declare function createSqliteSyncGatewayAdapter(): SyncGatewayAdapter;