@madauth/server 0.1.0

package/dist/index.js

@@ -0,0 +1,32 @@
+import {
+  columnName,
+  createTablesSql,
+  madauthSchema,
+  tableName
+} from "./chunk-3WIWWKRI.js";
+import {
+  REDIRECT_ERROR_PARAM,
+  createApp
+} from "./chunk-TEMZRMFF.js";
+import "./chunk-PRRKLEW7.js";
+import {
+  ConfigError,
+  envVars,
+  loadConfig
+} from "./chunk-V2XKGETK.js";
+import {
+  generateSigningKey
+} from "./chunk-JDQLSL36.js";
+import "./chunk-AVZE6FFR.js";
+export {
+  ConfigError,
+  REDIRECT_ERROR_PARAM,
+  columnName,
+  createApp,
+  createTablesSql,
+  envVars,
+  generateSigningKey,
+  loadConfig,
+  madauthSchema,
+  tableName
+};

package/dist/schema-Dotc6LU7.d.ts

@@ -0,0 +1,137 @@
+/** A value of a record field. */
+type Value = string | number | boolean | null;
+/** A record: field name → value. Field names are the camelCase names from {@link madauthSchema}. */
+type Row = Record<string, Value>;
+/** Filter: every field must equal the given value (`null` matches empty fields). */
+type Where = Record<string, Value>;
+/**
+ * Stores madAuth's records in a database. madAuth does all the security work (hashing, throttling,
+ * single-use links); an adapter only stores the models of {@link madauthSchema}.
+ *
+ * Check an implementation with `storeAdapterContract` from `@madauth/server/testing`.
+ */
+interface StoreAdapter {
+    /** Inserts a record. Resolves to false and writes nothing if a `unique` or primary-key value already exists. */
+    create(model: string, data: Row): Promise<boolean>;
+    findOne(model: string, where: Where): Promise<Row | null>;
+    findMany(model: string, where: Where, opts?: {
+        limit?: number;
+    }): Promise<Row[]>;
+    /** Changes the given fields of the matching records. Resolves to the number of records changed. */
+    update(model: string, where: Where, patch: Row): Promise<number>;
+    /**
+     * Deletes the matching records. Resolves to the number of records deleted; madAuth relies on this count
+     * to use a link or code only once, so it must be exact when two requests delete the same record.
+     */
+    delete(model: string, where: Where): Promise<number>;
+}
+type FieldType = 'string' | 'number' | 'boolean';
+interface FieldDef {
+    type: FieldType;
+    primaryKey?: boolean;
+    unique?: boolean;
+    /** Looked up often, so it should have an index. */
+    index?: boolean;
+    nullable?: boolean;
+}
+interface Schema {
+    /** Increases with every change to the models. */
+    version: number;
+    models: Record<string, {
+        fields: Record<string, FieldDef>;
+    }>;
+}
+/** The records madAuth stores. Timestamps are milliseconds since 1970. */
+declare const madauthSchema: {
+    readonly version: 1;
+    readonly models: {
+        readonly user: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly primaryKey: true;
+                };
+                readonly email: {
+                    readonly type: "string";
+                };
+                readonly emailNormalized: {
+                    readonly type: "string";
+                    readonly unique: true;
+                };
+                readonly emailVerified: {
+                    readonly type: "boolean";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly nullable: true;
+                };
+                readonly sessionVersion: {
+                    readonly type: "number";
+                };
+                readonly lastMailAt: {
+                    readonly type: "number";
+                };
+                readonly createdAt: {
+                    readonly type: "number";
+                };
+            };
+        };
+        /** How a user signs in. `key` is e.g. `password:<userId>`; later `google:<sub>` or `totp:<userId>`. */
+        readonly account: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly primaryKey: true;
+                };
+                readonly userId: {
+                    readonly type: "string";
+                    readonly index: true;
+                };
+                readonly key: {
+                    readonly type: "string";
+                    readonly unique: true;
+                };
+                readonly secret: {
+                    readonly type: "string";
+                    readonly nullable: true;
+                };
+                readonly failedAttempts: {
+                    readonly type: "number";
+                };
+                readonly lockedUntil: {
+                    readonly type: "number";
+                };
+                readonly createdAt: {
+                    readonly type: "number";
+                };
+            };
+        };
+        /** A pending e-mail verification or password reset. `id` is the SHA-256 of the link token. */
+        readonly verification: {
+            readonly fields: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly primaryKey: true;
+                };
+                readonly userId: {
+                    readonly type: "string";
+                    readonly index: true;
+                };
+                readonly purpose: {
+                    readonly type: "string";
+                };
+                readonly codeHash: {
+                    readonly type: "string";
+                };
+                readonly attempts: {
+                    readonly type: "number";
+                };
+                readonly expiresAt: {
+                    readonly type: "number";
+                };
+            };
+        };
+    };
+};
+
+export { type FieldDef as F, type Row as R, type StoreAdapter as S, type Value as V, type Where as W, type Schema as a, type FieldType as b, madauthSchema as m };

package/dist/sqlite.js

@@ -0,0 +1,100 @@
+import {
+  columnName,
+  createTablesSql,
+  madauthSchema,
+  tableName
+} from "./chunk-3WIWWKRI.js";
+
+// src/store/sqlite.ts
+function createSqliteAdapter(path) {
+  const { DatabaseSync } = process.getBuiltinModule("node:sqlite");
+  const db = new DatabaseSync(path);
+  db.exec("PRAGMA busy_timeout = 5000");
+  if (path !== ":memory:") db.exec("PRAGMA journal_mode = WAL");
+  migrate(db);
+  const fieldsOf = (model) => {
+    const fields = madauthSchema.models[model]?.fields;
+    if (!fields) throw new Error(`Unknown model "${model}"`);
+    return fields;
+  };
+  const column = (fields, field) => {
+    if (!fields[field]) throw new Error(`Unknown field "${field}"`);
+    return columnName(field);
+  };
+  const toSql = (value) => typeof value === "boolean" ? value ? 1 : 0 : value;
+  const whereSql = (fields, where) => {
+    const parts = [];
+    const params = [];
+    for (const [field, value] of Object.entries(where)) {
+      if (value === null) {
+        parts.push(`${column(fields, field)} IS NULL`);
+      } else {
+        parts.push(`${column(fields, field)} = ?`);
+        params.push(toSql(value));
+      }
+    }
+    return { sql: parts.length ? ` WHERE ${parts.join(" AND ")}` : "", params };
+  };
+  const fromSql = (fields, raw) => {
+    const row = {};
+    for (const [field, def] of Object.entries(fields)) {
+      const value = raw[columnName(field)];
+      row[field] = def.type === "boolean" && value !== null ? value === 1 : value;
+    }
+    return row;
+  };
+  return {
+    async create(model, data) {
+      const fields = fieldsOf(model);
+      const names = Object.keys(data);
+      const sql = `INSERT INTO ${tableName(model)} (${names.map((f) => column(fields, f)).join(", ")}) VALUES (${names.map(() => "?").join(", ")}) ON CONFLICT DO NOTHING`;
+      return Number(db.prepare(sql).run(...names.map((f) => toSql(data[f]))).changes) === 1;
+    },
+    async findOne(model, where) {
+      const fields = fieldsOf(model);
+      const w = whereSql(fields, where);
+      const raw = db.prepare(`SELECT * FROM ${tableName(model)}${w.sql} LIMIT 1`).get(...w.params);
+      return raw ? fromSql(fields, raw) : null;
+    },
+    async findMany(model, where, opts = {}) {
+      const fields = fieldsOf(model);
+      const w = whereSql(fields, where);
+      const limit = opts.limit === void 0 ? "" : ` LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
+      return db.prepare(`SELECT * FROM ${tableName(model)}${w.sql}${limit}`).all(...w.params).map((raw) => fromSql(fields, raw));
+    },
+    async update(model, where, patch) {
+      const fields = fieldsOf(model);
+      const names = Object.keys(patch);
+      if (!names.length) return 0;
+      const w = whereSql(fields, where);
+      const sql = `UPDATE ${tableName(model)} SET ${names.map((f) => `${column(fields, f)} = ?`).join(", ")}${w.sql}`;
+      return Number(db.prepare(sql).run(...names.map((f) => toSql(patch[f])), ...w.params).changes);
+    },
+    async delete(model, where) {
+      const fields = fieldsOf(model);
+      const w = whereSql(fields, where);
+      return Number(db.prepare(`DELETE FROM ${tableName(model)}${w.sql}`).run(...w.params).changes);
+    }
+  };
+}
+function migrate(db) {
+  const { user_version: version } = db.prepare("PRAGMA user_version").get();
+  if (version > madauthSchema.version) {
+    throw new Error(
+      `The database uses madAuth schema version ${version}, but this madAuth only knows version ${madauthSchema.version}. Update madAuth.`
+    );
+  }
+  if (version === madauthSchema.version) return;
+  db.exec("BEGIN");
+  try {
+    db.exec(createTablesSql("sqlite"));
+    db.exec(`PRAGMA user_version = ${madauthSchema.version}`);
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
+export {
+  createSqliteAdapter
+};