@mrgnw/anahtar 0.0.23 → 0.0.24

package/dist/db/tinybase.d.ts

@@ -0,0 +1,7 @@
+import type { Store } from 'tinybase';
+import type { AuthDB } from '../types.js';
+interface TinybaseAdapterOptions {
+    tablePrefix?: string;
+}
+export declare function tinybaseAdapter(store: Store, options?: TinybaseAdapterOptions): AuthDB;
+export {};

package/dist/db/tinybase.js

@@ -0,0 +1,200 @@
+import { createIndexes } from 'tinybase/indexes';
+function encodeBytes(bytes) {
+    return btoa(String.fromCharCode(...bytes));
+}
+function decodeBytes(str) {
+    return Uint8Array.from(atob(str), (c) => c.charCodeAt(0));
+}
+export function tinybaseAdapter(store, options = {}) {
+    const p = options.tablePrefix ?? 'auth_';
+    const t = {
+        users: `${p}users`,
+        sessions: `${p}sessions`,
+        otpCodes: `${p}otp_codes`,
+        passkeys: `${p}passkeys`,
+        challenges: `${p}challenges`
+    };
+    const indexes = createIndexes(store);
+    return {
+        init() {
+            indexes.setIndexDefinition('email_to_user', t.users, 'email');
+            indexes.setIndexDefinition('email_to_otp', t.otpCodes, 'email');
+            indexes.setIndexDefinition('credential_to_passkey', t.passkeys, 'credential_id');
+            indexes.setIndexDefinition('user_to_passkey', t.passkeys, 'user_id');
+        },
+        getUserByEmail(email) {
+            const ids = indexes.getSliceRowIds('email_to_user', email);
+            if (!ids.length)
+                return null;
+            const row = store.getRow(t.users, ids[0]);
+            return {
+                id: ids[0],
+                email: row.email,
+                skipPasskeyPrompt: row.skip_passkey_prompt === 1,
+                createdAt: row.created_at
+            };
+        },
+        createUser(email) {
+            const id = crypto.randomUUID();
+            const createdAt = Math.floor(Date.now() / 1000);
+            store.setRow(t.users, id, {
+                email,
+                skip_passkey_prompt: 0,
+                created_at: createdAt
+            });
+            return { id, email, skipPasskeyPrompt: false, createdAt };
+        },
+        setSkipPasskeyPrompt(userId, skip) {
+            store.setCell(t.users, userId, 'skip_passkey_prompt', skip ? 1 : 0);
+        },
+        createSession(tokenHash, userId, expiresAt) {
+            store.setRow(t.sessions, tokenHash, {
+                user_id: userId,
+                expires_at: expiresAt,
+                created_at: Math.floor(Date.now() / 1000)
+            });
+        },
+        getSession(tokenHash) {
+            const session = store.getRow(t.sessions, tokenHash);
+            if (!session.user_id)
+                return null;
+            const userId = session.user_id;
+            const user = store.getRow(t.users, userId);
+            if (!user.email)
+                return null;
+            return {
+                id: tokenHash,
+                userId,
+                expiresAt: session.expires_at,
+                email: user.email
+            };
+        },
+        deleteSession(tokenHash) {
+            store.delRow(t.sessions, tokenHash);
+        },
+        storeOTP(email, id, code, expiresAt) {
+            store.setRow(t.otpCodes, id, {
+                email,
+                code,
+                attempts: 0,
+                expires_at: expiresAt,
+                created_at: Date.now()
+            });
+        },
+        getLatestOTP(email) {
+            const ids = indexes.getSliceRowIds('email_to_otp', email);
+            if (!ids.length)
+                return null;
+            let latestId = ids[0];
+            let latestCreatedAt = store.getCell(t.otpCodes, latestId, 'created_at');
+            for (let i = 1; i < ids.length; i++) {
+                const createdAt = store.getCell(t.otpCodes, ids[i], 'created_at');
+                if (createdAt > latestCreatedAt) {
+                    latestCreatedAt = createdAt;
+                    latestId = ids[i];
+                }
+            }
+            const row = store.getRow(t.otpCodes, latestId);
+            return {
+                id: latestId,
+                email: row.email,
+                code: row.code,
+                attempts: row.attempts,
+                expiresAt: row.expires_at
+            };
+        },
+        updateOTPAttempts(id, attempts) {
+            store.setCell(t.otpCodes, id, 'attempts', attempts);
+        },
+        deleteOTP(id) {
+            store.delRow(t.otpCodes, id);
+        },
+        deleteOTPsForEmail(email) {
+            const ids = indexes.getSliceRowIds('email_to_otp', email);
+            for (const id of ids) {
+                store.delRow(t.otpCodes, id);
+            }
+        },
+        storeChallenge(challenge, userId, expiresAt) {
+            // Clean up expired challenges
+            const now = Date.now();
+            store.forEachRow(t.challenges, (rowId) => {
+                const exp = store.getCell(t.challenges, rowId, 'expires_at');
+                if (exp < now)
+                    store.delRow(t.challenges, rowId);
+            });
+            store.setRow(t.challenges, challenge, {
+                user_id: userId,
+                expires_at: expiresAt,
+                created_at: Math.floor(Date.now() / 1000)
+            });
+        },
+        consumeChallenge(challenge) {
+            const row = store.getRow(t.challenges, challenge);
+            if (!row.user_id)
+                return null;
+            store.delRow(t.challenges, challenge);
+            if (row.expires_at < Date.now())
+                return null;
+            return { userId: row.user_id };
+        },
+        getPasskeyByCredentialId(credentialId) {
+            const ids = indexes.getSliceRowIds('credential_to_passkey', credentialId);
+            if (!ids.length)
+                return null;
+            const id = ids[0];
+            const row = store.getRow(t.passkeys, id);
+            const userId = row.user_id;
+            const user = store.getRow(t.users, userId);
+            if (!user.email)
+                return null;
+            return {
+                id,
+                userId,
+                credentialId: row.credential_id,
+                publicKey: decodeBytes(row.public_key),
+                counter: row.counter,
+                transports: row.transports ?? null,
+                name: row.name ?? null,
+                createdAt: row.created_at,
+                email: user.email
+            };
+        },
+        getUserPasskeys(userId) {
+            const ids = indexes.getSliceRowIds('user_to_passkey', userId);
+            return ids.map((id) => {
+                const row = store.getRow(t.passkeys, id);
+                return {
+                    id,
+                    credentialId: row.credential_id,
+                    publicKey: decodeBytes(row.public_key),
+                    counter: row.counter,
+                    transports: row.transports ?? null,
+                    name: row.name ?? null,
+                    createdAt: row.created_at
+                };
+            });
+        },
+        storePasskey(passkey) {
+            store.setRow(t.passkeys, passkey.id, {
+                user_id: passkey.userId,
+                credential_id: passkey.credentialId,
+                public_key: encodeBytes(passkey.publicKey),
+                counter: passkey.counter,
+                ...(passkey.transports !== null && { transports: passkey.transports }),
+                ...(passkey.name !== null && { name: passkey.name }),
+                created_at: Math.floor(Date.now() / 1000)
+            });
+        },
+        updatePasskeyCounter(id, counter) {
+            store.setCell(t.passkeys, id, 'counter', counter);
+        },
+        deletePasskey(id, userId) {
+            const row = store.getRow(t.passkeys, id);
+            if (!row.user_id || row.user_id !== userId)
+                return false;
+            store.delRow(t.passkeys, id);
+            return true;
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrgnw/anahtar",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "Opinionated, reusable auth for SvelteKit. Email+OTP + passkeys.",
   "license": "MIT",
   "type": "module",
@@ -32,6 +32,10 @@
       "types": "./dist/db/d1.d.ts",
       "default": "./dist/db/d1.js"
     },
+    "./tinybase": {
+      "types": "./dist/db/tinybase.d.ts",
+      "default": "./dist/db/tinybase.js"
+    },
     "./components": {
       "types": "./dist/components/index.d.ts",
       "svelte": "./dist/components/index.js",
@@ -45,7 +49,8 @@
   "peerDependencies": {
     "@simplewebauthn/browser": "^13.0.0",
     "@sveltejs/kit": "^2.0.0",
-    "svelte": "^5.0.0"
+    "svelte": "^5.0.0",
+    "tinybase": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "svelte": {
@@ -53,6 +58,9 @@
     },
     "@simplewebauthn/browser": {
       "optional": true
+    },
+    "tinybase": {
+      "optional": true
     }
   },
   "dependencies": {
@@ -70,6 +78,7 @@
     "@testing-library/user-event": "^14.6.1",
     "@types/better-sqlite3": "^7.6.13",
     "better-sqlite3": "^12.6.2",
+    "tinybase": "^8.0.1",
     "happy-dom": "^20.6.1",
     "svelte": "^5.38.1",
     "svelte-check": "^4.3.1",