@chidchanun/bcp 0.1.14 → 0.1.16

package/packages/cli/src/index.ts

@@ -66,6 +66,11 @@ switch (cliOptions.command) {
     break;
   }
 
+  case "db": {
+    await runDatabaseCommand();
+    break;
+  }
+
   case "help": {
     printHelp();
     break;
@@ -381,6 +386,86 @@ async function runUpdate() {
   });
 }
 
+async function runDatabaseCommand() {
+  const action =
+    cliOptions.dbAction;
+
+  if (
+    action === undefined ||
+    action === "help"
+  ) {
+    printDatabaseHelp();
+    return;
+  }
+
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+
+  process.env.NODE_ENV =
+    process.env.NODE_ENV ??
+    "development";
+
+  const {
+    loadEnvironment,
+  } =
+    await import(
+      "../../env/src/index.js"
+    );
+
+  const environment =
+    loadEnvironment(
+      rootDirectory,
+      "development"
+    );
+
+  if (
+    environment.files.length > 0
+  ) {
+    console.log(
+      `[BCP Env] development: ${environment.files.join(", ")}`
+    );
+  }
+
+  const {
+    runDatabaseMigrationCommand,
+  } =
+    await import(
+      "./database-migrations.js"
+    );
+
+  if (
+    action === "create"
+  ) {
+    await runDatabaseMigrationCommand({
+      rootDirectory,
+      action,
+      name:
+        cliOptions.dbMigrationName,
+    });
+    return;
+  }
+
+  const {
+    db,
+  } =
+    await import(
+      "../../client/src/database.js"
+    );
+
+  try {
+    await runDatabaseMigrationCommand({
+      rootDirectory,
+      action,
+      database:
+        db,
+    });
+  } finally {
+    await db.close();
+  }
+}
+
 function installShutdownHandlers(
   server: {
     stop(): Promise<void>;
@@ -521,6 +606,28 @@ function formatBytes(
   ).toFixed(2)} MiB`;
 }
 
+function printDatabaseHelp() {
+  console.log(`
+BCP Database Migrations
+
+Usage:
+  bcp db <command> [arguments]
+
+Commands:
+  create <name>       Create a timestamped migration in migrations/
+  migrate             Run all pending migrations
+  status              Show applied and pending migrations
+  rollback            Roll back the latest migration batch
+  help                Show database command help
+
+Examples:
+  bcp db create create_users
+  bcp db migrate
+  bcp db status
+  bcp db rollback
+`);
+}
+
 function printHelp() {
   console.log(`
 BCP Framework v${FRAMEWORK_VERSION}
@@ -534,6 +641,7 @@ Commands:
   start              Start the standalone production build
   routes             Print discovered page and API routes
   update [target]    Update BCP Framework (default target: latest)
+  db <command>       Manage database migrations
   help               Show this help message
   version            Show framework version
 
@@ -558,6 +666,9 @@ Examples:
   bcp routes
   bcp update
   bcp update --check
-  bcp update 0.1.10
+  bcp db create create_users
+  bcp db migrate
+  bcp db status
+  bcp db rollback
 `);
 }

package/packages/client/src/auth.ts

@@ -0,0 +1,14 @@
+export {
+    auth,
+    createAuth,
+    getSession,
+    login,
+    logout,
+    rotateSession,
+
+    type AuthApi,
+    type AuthLoginOptions,
+    type AuthOptions,
+    type AuthSession,
+    type AuthUser,
+} from "../../server/src/auth.js";

package/packages/server/src/auth.ts

@@ -0,0 +1,376 @@
+import {
+    randomUUID,
+} from "node:crypto";
+
+import {
+    createSession,
+    destroySession,
+    getSession as readSession,
+    type SessionClaims,
+    type SessionCookieOptions,
+} from "./session.js";
+
+export interface AuthUser {
+    id: string | number;
+}
+
+export interface AuthSession<
+    TUser extends AuthUser = AuthUser,
+    TData extends object = Record<string, never>
+> extends SessionClaims {
+    sid: string;
+    user: TUser;
+    data?: TData;
+}
+
+export interface AuthOptions
+extends SessionCookieOptions {}
+
+export interface AuthLoginOptions<
+    TData extends object = Record<string, never>
+> extends AuthOptions {
+    data?: TData;
+}
+
+export interface AuthApi<
+    TUser extends AuthUser = AuthUser,
+    TData extends object = Record<string, never>
+> {
+    auth(
+        options?: AuthOptions
+    ): Promise<AuthSession<TUser, TData> | null>;
+    getSession(
+        options?: AuthOptions
+    ): Promise<AuthSession<TUser, TData> | null>;
+    login(
+        user: TUser,
+        options?: AuthLoginOptions<TData>
+    ): Promise<AuthSession<TUser, TData>>;
+    logout(
+        options?: AuthOptions
+    ): Promise<void>;
+    rotateSession(
+        options?: AuthOptions
+    ): Promise<AuthSession<TUser, TData> | null>;
+}
+
+interface AuthSessionPayload<
+    TUser extends AuthUser,
+    TData extends object
+> {
+    sid: string;
+    user: TUser;
+    data?: TData;
+}
+
+export async function auth<
+    TUser extends AuthUser = AuthUser,
+    TData extends object = Record<string, never>
+>(
+    options: AuthOptions = {}
+): Promise<AuthSession<TUser, TData> | null> {
+    const session =
+        await readSession<
+            AuthSessionPayload<
+                TUser,
+                TData
+            >
+        >(
+            options
+        );
+
+    if (!session) {
+        return null;
+    }
+
+    if (
+        typeof session.sid !==
+            "string" ||
+        session.sid.trim().length ===
+            0 ||
+        !isAuthUser(
+            session.user
+        )
+    ) {
+        return null;
+    }
+
+    if (
+        session.data !== undefined &&
+        !isPlainObject(
+            session.data
+        )
+    ) {
+        return null;
+    }
+
+    return session as
+        AuthSession<
+            TUser,
+            TData
+        >;
+}
+
+export async function getSession<
+    TUser extends AuthUser = AuthUser,
+    TData extends object = Record<string, never>
+>(
+    options: AuthOptions = {}
+): Promise<AuthSession<TUser, TData> | null> {
+    return auth<
+        TUser,
+        TData
+    >(
+        options
+    );
+}
+
+export async function login<
+    TUser extends AuthUser,
+    TData extends object = Record<string, never>
+>(
+    user: TUser,
+    options:
+        AuthLoginOptions<TData> = {}
+): Promise<AuthSession<TUser, TData>> {
+    assertAuthUser(
+        user
+    );
+
+    if (
+        options.data !== undefined &&
+        !isPlainObject(
+            options.data
+        )
+    ) {
+        throw new TypeError(
+            "BCP Auth: session data must be a plain object."
+        );
+    }
+
+    const {
+        data,
+        ...sessionOptions
+    } = options;
+    const payload:
+        AuthSessionPayload<
+            TUser,
+            TData
+        > = {
+        sid:
+            randomUUID(),
+        user,
+        ...(data === undefined
+            ? {}
+            : {
+                data,
+            }),
+    };
+
+    await createSession(
+        payload,
+        sessionOptions
+    );
+
+    const session =
+        await auth<
+            TUser,
+            TData
+        >(
+            sessionOptions
+        );
+
+    if (!session) {
+        throw new Error(
+            "BCP Auth: login created a session but it could not be read back."
+        );
+    }
+
+    return session;
+}
+
+export async function logout(
+    options: AuthOptions = {}
+): Promise<void> {
+    await destroySession(
+        options
+    );
+}
+
+export async function rotateSession<
+    TUser extends AuthUser = AuthUser,
+    TData extends object = Record<string, never>
+>(
+    options: AuthOptions = {}
+): Promise<AuthSession<TUser, TData> | null> {
+    const current =
+        await auth<
+            TUser,
+            TData
+        >(
+            options
+        );
+
+    if (!current) {
+        return null;
+    }
+
+    return login<
+        TUser,
+        TData
+    >(
+        current.user,
+        {
+            ...options,
+            issuer:
+                options.issuer ??
+                current.iss,
+            audience:
+                options.audience ??
+                current.aud,
+            ...(current.data === undefined
+                ? {}
+                : {
+                    data:
+                        current.data,
+                }),
+        }
+    );
+}
+
+export function createAuth<
+    TUser extends AuthUser = AuthUser,
+    TData extends object = Record<string, never>
+>(
+    defaults: AuthOptions = {}
+): AuthApi<TUser, TData> {
+    return {
+        auth: (
+            options = {}
+        ) =>
+            auth<
+                TUser,
+                TData
+            >({
+                ...defaults,
+                ...options,
+            }),
+        getSession: (
+            options = {}
+        ) =>
+            auth<
+                TUser,
+                TData
+            >({
+                ...defaults,
+                ...options,
+            }),
+        login: (
+            user,
+            options = {}
+        ) => {
+            const {
+                data,
+                ...sessionOptions
+            } = options;
+
+            return login<
+                TUser,
+                TData
+            >(
+                user,
+                {
+                    ...defaults,
+                    ...sessionOptions,
+                    ...(data === undefined
+                        ? {}
+                        : {
+                            data,
+                        }),
+                }
+            );
+        },
+        logout: (
+            options = {}
+        ) =>
+            logout({
+                ...defaults,
+                ...options,
+            }),
+        rotateSession: (
+            options = {}
+        ) =>
+            rotateSession<
+                TUser,
+                TData
+            >({
+                ...defaults,
+                ...options,
+            }),
+    };
+}
+
+function assertAuthUser(
+    value: unknown
+): asserts value is AuthUser {
+    if (
+        !isAuthUser(
+            value
+        )
+    ) {
+        throw new TypeError(
+            "BCP Auth: user must be a plain object with a non-empty string or finite numeric id."
+        );
+    }
+}
+
+function isAuthUser(
+    value: unknown
+): value is AuthUser {
+    if (
+        !isPlainObject(
+            value
+        )
+    ) {
+        return false;
+    }
+
+    const id =
+        value.id;
+
+    return (
+        typeof id === "string" &&
+        id.trim().length > 0
+    ) || (
+        typeof id === "number" &&
+        Number.isFinite(
+            id
+        )
+    );
+}
+
+function isPlainObject(
+    value: unknown
+): value is Record<string, unknown> {
+    if (
+        value === null ||
+        typeof value !== "object" ||
+        Array.isArray(
+            value
+        )
+    ) {
+        return false;
+    }
+
+    const prototype =
+        Object.getPrototypeOf(
+            value
+        );
+
+    return (
+        prototype ===
+            Object.prototype ||
+        prototype ===
+            null
+    );
+}