@sqrzro/server 2.0.0-bz.1 → 2.0.0-bz.11

package/dist/schema.d.ts

@@ -0,0 +1,288 @@
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+
+declare const mfaType: drizzle_orm_pg_core.PgEnum<["TOTP", "HARDWARE"]>;
+declare const scope: drizzle_orm_pg_core.PgEnum<["ANON", "MFA", "AUTHED"]>;
+type Scope = (typeof scope.enumValues)[number];
+declare const authSchema: drizzle_orm_pg_core.PgSchema<"auth">;
+declare const authUserTable: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "user_credentials";
+    schema: "auth";
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "user_credentials";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        email: drizzle_orm_pg_core.PgColumn<{
+            name: "email";
+            tableName: "user_credentials";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        password: drizzle_orm_pg_core.PgColumn<{
+            name: "password";
+            tableName: "user_credentials";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        role: drizzle_orm_pg_core.PgColumn<{
+            name: "role";
+            tableName: "user_credentials";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type AuthUser = typeof authUserTable.$inferSelect;
+declare const authSessionTable: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "sessions";
+    schema: "auth";
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "userId";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        scope: drizzle_orm_pg_core.PgColumn<{
+            name: "scope";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "ANON" | "MFA" | "AUTHED";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: ["ANON", "MFA", "AUTHED"];
+            baseColumn: never;
+        }, {}, {}>;
+        expiresAt: drizzle_orm_pg_core.PgColumn<{
+            name: "expiresAt";
+            tableName: "sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type AuthSession = typeof authSessionTable.$inferSelect;
+declare const authResetTable: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "resets";
+    schema: "auth";
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "resets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "userId";
+            tableName: "resets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        expiresAt: drizzle_orm_pg_core.PgColumn<{
+            name: "expiresAt";
+            tableName: "resets";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type AuthReset = typeof authResetTable.$inferSelect;
+declare const authMFATable: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "mfas";
+    schema: "auth";
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "mfas";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        name: drizzle_orm_pg_core.PgColumn<{
+            name: "name";
+            tableName: "mfas";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "userId";
+            tableName: "mfas";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        type: drizzle_orm_pg_core.PgColumn<{
+            name: "type";
+            tableName: "mfas";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "TOTP" | "HARDWARE";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: ["TOTP", "HARDWARE"];
+            baseColumn: never;
+        }, {}, {}>;
+        secret: drizzle_orm_pg_core.PgColumn<{
+            name: "secret";
+            tableName: "mfas";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        verifiedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "verifiedAt";
+            tableName: "mfas";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type AuthMFA = typeof authMFATable.$inferSelect;
+declare const authClientTable: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "client_credentials";
+    schema: "auth";
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "client_credentials";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        alias: drizzle_orm_pg_core.PgColumn<{
+            name: "alias";
+            tableName: "client_credentials";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        secret: drizzle_orm_pg_core.PgColumn<{
+            name: "secret";
+            tableName: "client_credentials";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type AuthClient = typeof authClientTable.$inferSelect;
+
+export { type AuthClient, type AuthMFA, type AuthReset, type AuthSession, type AuthUser, type Scope, authClientTable, authMFATable, authResetTable, authSchema, authSessionTable, authUserTable, mfaType, scope };

package/dist/schema.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/database/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  authClientTable: () => authClientTable,
+  authMFATable: () => authMFATable,
+  authResetTable: () => authResetTable,
+  authSchema: () => authSchema,
+  authSessionTable: () => authSessionTable,
+  authUserTable: () => authUserTable,
+  mfaType: () => mfaType,
+  scope: () => scope
+});
+module.exports = __toCommonJS(schema_exports);
+var import_pg_core = require("drizzle-orm/pg-core");
+var DEFAULT_ROLE = 10;
+var mfaType = (0, import_pg_core.pgEnum)("mfaType", ["TOTP", "HARDWARE"]);
+var scope = (0, import_pg_core.pgEnum)("scope", ["ANON", "MFA", "AUTHED"]);
+var authSchema = (0, import_pg_core.pgSchema)("auth");
+var authUserTable = authSchema.table("user_credentials", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  email: (0, import_pg_core.text)("email").notNull().unique(),
+  password: (0, import_pg_core.text)("password"),
+  role: (0, import_pg_core.integer)("role").notNull().default(DEFAULT_ROLE)
+});
+var authSessionTable = authSchema.table("sessions", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  userId: (0, import_pg_core.text)("userId").notNull().references(() => authUserTable.id),
+  scope: scope("scope").notNull().default("ANON"),
+  expiresAt: (0, import_pg_core.timestamp)("expiresAt").notNull()
+});
+var authResetTable = authSchema.table("resets", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  userId: (0, import_pg_core.text)("userId").notNull().references(() => authUserTable.id),
+  expiresAt: (0, import_pg_core.timestamp)("expiresAt").notNull()
+});
+var authMFATable = authSchema.table("mfas", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  name: (0, import_pg_core.text)("name").notNull(),
+  userId: (0, import_pg_core.text)("userId").notNull().references(() => authUserTable.id),
+  type: mfaType("type").notNull().default("TOTP"),
+  secret: (0, import_pg_core.text)("secret").notNull(),
+  verifiedAt: (0, import_pg_core.timestamp)("verifiedAt")
+});
+var authClientTable = authSchema.table("client_credentials", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  alias: (0, import_pg_core.text)("alias").notNull().unique(),
+  secret: (0, import_pg_core.text)("secret").notNull().unique()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authClientTable,
+  authMFATable,
+  authResetTable,
+  authSchema,
+  authSessionTable,
+  authUserTable,
+  mfaType,
+  scope
+});

package/dist/url.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Uses a number of methods to determine the current origin.
+ *
+ * First, it checks if an `x-origin` header. This will have been set by the `handleMiddleware`
+ * function, further up the chain. For more information on how it is being set, see the
+ * `middleware` documentation.
+ *
+ * There are some situations where middleware is not being applied, such as API routes (because the
+ * redirection is not necessary, and API routes handle their own authentication). In these cases,
+ * this function tries to piece together the origin from the `x-forwarded-proto` and
+ * `x-forwarded-host` headers.
+ *
+ * Finally, if the origin cannot be determined, an error is thrown.
+ *
+ * @returns The origin of the current request.
+ */
+declare function getOrigin(): string;
+/**
+ * Builds a URL from the current origin and a given pathname. For more information on how the origin
+ * is determined, see the `getOrigin` function. This function then just concatenates the origin and
+ * the pathname, and performs some cleanup to ensure the URL is valid.
+ *
+ * @param pathname
+ * @returns The URL, with the origin and pathname combined.
+ */
+declare function getURL(pathname?: string): string;
+
+export { getOrigin, getURL };

package/dist/url.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/url/index.ts
+var url_exports = {};
+__export(url_exports, {
+  getOrigin: () => getOrigin,
+  getURL: () => getURL
+});
+module.exports = __toCommonJS(url_exports);
+
+// src/url/URLService.ts
+var import_headers = require("next/headers");
+function getOrigin() {
+  const origin = (0, import_headers.headers)().get("x-origin");
+  if (origin) {
+    return origin;
+  }
+  const proto = (0, import_headers.headers)().get("x-forwarded-proto");
+  const host = (0, import_headers.headers)().get("x-forwarded-host");
+  if (proto && host) {
+    return `${proto}://${host}`;
+  }
+  throw new Error("No origin could be determined");
+}
+function getURL(pathname) {
+  const origin = getOrigin();
+  if (!pathname) {
+    return origin;
+  }
+  const isSecure = origin.startsWith("https://");
+  const protocol = isSecure ? "https://" : "http://";
+  const originWithoutProtocol = origin.replace(/^https?:\/\//u, "");
+  const cleanURL = `${originWithoutProtocol}/${pathname}`.replace(/\/+/gu, "/");
+  return `${protocol}${cleanURL}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getOrigin,
+  getURL
+});

package/forms.d.ts

@@ -0,0 +1 @@
+export * from './dist/forms/index';

package/forms.js

@@ -0,0 +1 @@
+module.exports = require('./dist/forms/index');

package/lists.d.ts

@@ -0,0 +1 @@
+export * from './dist/lists/index';

package/lists.js

@@ -0,0 +1 @@
+module.exports = require('./dist/lists/index');

package/mail.d.ts

@@ -0,0 +1 @@
+export * from './dist/mail/index';

package/mail.js

@@ -0,0 +1 @@
+module.exports = require('./dist/mail/index');

package/middleware.d.ts

@@ -0,0 +1 @@
+export * from './dist/middleware';

package/middleware.js

@@ -0,0 +1 @@
+module.exports = require('./dist/middleware');

package/package.json

@@ -1,45 +1,68 @@
 {
-    "name": "@sqrzro/server",
-    "version": "2.0.0-bz.1",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "exports": {
-        ".": "./dist/index.js"
-    },
-    "license": "ISC",
-    "files": [
-        "dist"
-    ],
-    "dependencies": {
-        "@sqrzro/utility": "workspace:bz",
-        "bcryptjs": "^2.4.3",
-        "joi": "^17.11.0",
-        "jose": "^5.0.1",
-        "next": "^14.0.0",
-        "react": "^18.2.0",
-        "react-dom": "^18.2.0",
-        "uuid": "^9.0.1"
-    },
-    "devDependencies": {
-        "@sqrzro/eslint-plugin": "workspace:bz",
-        "@sqrzro/prettier-config": "workspace:bz",
-        "@types/bcryptjs": "^2.4.6",
-        "@types/react": "^18.0.28",
-        "@types/uuid": "^9.0.7",
-        "esbuild": "^0.19.5",
-        "eslint": "^8.55.0",
-        "prettier": "^2.8.4",
-        "rimraf": "^4.1.2",
-        "tslib": "^2.3.1",
-        "typescript": "^5.2.2"
-    },
-    "scripts": {
-        "build": "pnpm clean && tsc --project tsconfig.build.json",
-        "clean": "rimraf ./dist",
-        "dev": "tsc -p tsconfig.build.json -w",
-        "lint": "tsc --noEmit && eslint \"./src/**/*.ts\"",
-        "prepublishOnly": "pnpm build",
-        "prettier": "prettier --write \"./src/**/*.ts\"",
-        "start": "pnpm dev"
-    }
-}
+  "name": "@sqrzro/server",
+  "version": "2.0.0-bz.11",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "ISC",
+  "files": [
+    "dist",
+    "auth.d.ts",
+    "auth.js",
+    "cache.d.ts",
+    "cache.js",
+    "forms.d.ts",
+    "forms.js",
+    "lists.d.ts",
+    "lists.js",
+    "mail.d.ts",
+    "mail.js",
+    "middleware.d.ts",
+    "middleware.js",
+    "schema.d.ts",
+    "schema.js",
+    "url.d.ts",
+    "url.js"
+  ],
+  "dependencies": {
+    "@lucia-auth/adapter-drizzle": "^1.0.2",
+    "@sqrzro/interfaces": "bz",
+    "@sqrzro/utility": "bz",
+    "bcryptjs": "^2.4.3",
+    "drizzle-orm": "^0.29.5",
+    "joi": "^17.12.2",
+    "jsonwebtoken": "^9.0.2",
+    "lucia": "^3.0.1",
+    "next": "^14.1.3",
+    "otplib": "^12.0.1",
+    "path-to-regexp": "^6.2.1",
+    "postgres": "^3.4.3",
+    "qrcode": "^1.5.3",
+    "react-dom": "18.3.0-canary-98b8359f6-20240223",
+    "redis": "^4.6.13"
+  },
+  "devDependencies": {
+    "@sqrzro/eslint-plugin": "bz",
+    "@sqrzro/prettier-config": "bz",
+    "@types/bcryptjs": "^2.4.6",
+    "@types/jest": "^29.5.12",
+    "@types/qrcode": "^1.5.5",
+    "@types/react-dom": "^18.2.21",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "rimraf": "^4.4.1",
+    "ts-jest": "^29.1.2",
+    "tslib": "^2.6.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.2"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsup --entry.auth src/auth/index.ts --entry.cache src/cache/index.ts --entry.forms src/forms/index.ts --entry.lists src/lists/index.ts --entry.mail src/mail/index.ts --entry.middleware src/middleware.ts --entry.schema src/database/schema.ts --entry.url src/url/index.ts --dts",
+    "clean": "rimraf ./dist",
+    "dev": "tsc -p tsconfig.build.json -w",
+    "lint": "tsc --noEmit && eslint \"./src/**/*.ts\"",
+    "prettier": "prettier --write \"./src/**/*.ts\"",
+    "start": "pnpm dev",
+    "test": "jest"
+  }
+}

package/schema.d.ts

@@ -0,0 +1 @@
+export * from './dist/database/schema';

package/schema.js

@@ -0,0 +1 @@
+module.exports = require('./dist/database/schema');

package/url.d.ts

@@ -0,0 +1 @@
+export * from './dist/url/index';

package/url.js

@@ -0,0 +1 @@
+module.exports = require('./dist/url/index');

package/dist/AuthService.d.ts

@@ -1,10 +0,0 @@
-import type { NextRequest } from 'next/server';
-import { NextResponse } from 'next/server';
-import type { Errorable, UserObject } from './interfaces';
-export declare function handleLogin(formData: FormData, lookupFn: (email: string) => Promise<UserObject | null>): Promise<Errorable<UserObject>>;
-interface MeObject {
-    name: string;
-    email: string;
-}
-export declare function handleMe(request: NextRequest, lookupFn: (id: number) => Promise<MeObject | null>): Promise<NextResponse>;
-export {};

package/dist/AuthService.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMe = exports.handleLogin = void 0;
-const tslib_1 = require("tslib");
-const server_1 = require("next/server");
-const DataService_1 = require("./DataService");
-const PasswordService_1 = require("./PasswordService");
-const SessionService_1 = require("./SessionService");
-const LoginRequest_1 = tslib_1.__importDefault(require("./LoginRequest"));
-async function handleLogin(formData, lookupFn) {
-    async function mutateFn(data) {
-        const user = await lookupFn(data.email);
-        const isUserValid = await (0, PasswordService_1.verifyPassword)(data.password, user?.password);
-        return user && isUserValid ? user : null;
-    }
-    const response = await (0, DataService_1.mutate)({
-        fn: mutateFn,
-        formData,
-        request: LoginRequest_1.default,
-        onSuccess: async (user) => {
-            await (0, SessionService_1.createSessionForId)(user.id);
-        },
-    });
-    return response;
-}
-exports.handleLogin = handleLogin;
-async function handleMe(request, lookupFn) {
-    const token = new URL(request.url).searchParams.get('token');
-    const userId = await (0, SessionService_1.getIdFromToken)(token);
-    const me = await lookupFn(userId);
-    if (!me) {
-        return server_1.NextResponse.json({ valid: false }, { status: 401 });
-    }
-    return server_1.NextResponse.json({ name: me.name, email: me.email, valid: true });
-}
-exports.handleMe = handleMe;