nuxt-users 1.6.3 → 1.6.4

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 
 
+## v1.6.4
+
+[compare changes](https://github.com/rrd108/nuxt-users/compare/v1.6.3...v1.6.4)
+
+### 💅 Refactors
+
+- Move utils to runtime/server ([78a5b50](https://github.com/rrd108/nuxt-users/commit/78a5b50))
+
+### 🏡 Chore
+
+- **release:** V1.6.3 ([365cfe2](https://github.com/rrd108/nuxt-users/commit/365cfe2))
+- Fix formatting ([fdec442](https://github.com/rrd108/nuxt-users/commit/fdec442))
+
+### ❤️ Contributors
+
+- Rrd108 ([@rrd108](https://github.com/rrd108))
+
 ## v1.6.3
 
 [compare changes](https://github.com/rrd108/nuxt-users/compare/v1.6.2...v1.6.3)

package/dist/cli.mjs

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
-import 'db0';
-import 'bcrypt';
-import { r as runMigrations, j as getPasswordValidationOptions, v as validatePassword, a as createUser$1, d as createUsersTable$1, e as createPersonalAccessTokensTable$1, h as createPasswordResetTokensTable$1, i as createMigrationsTable$1 } from './shared/nuxt-users.C_UkhLJ9.mjs';
+import { runMigrations, createUser as createUser$1, createUsersTable as createUsersTable$1, createPersonalAccessTokensTable as createPersonalAccessTokensTable$1, createPasswordResetTokensTable as createPasswordResetTokensTable$1, createMigrationsTable as createMigrationsTable$1 } from '../dist/runtime/server/utils/index.js';
 import { defaultOptions } from './module.mjs';
 import { loadNuxt } from '@nuxt/kit';
+import { getPasswordValidationOptions, validatePassword } from './utils.mjs';
 import 'defu';
 
 const getOptionsFromEnv = () => {
@@ -248,7 +247,7 @@ const main = defineCommand({
   meta: {
     name: "nuxt-users",
     description: "CLI for Nuxt Users Module - Manage users, migrations, and database operations",
-    version: "1.1.3"
+    version: "1.6.3"
   },
   subCommands: {
     migrate,

package/dist/module.d.mts

@@ -1,5 +1,118 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleOptions } from './shared/nuxt-users.CMEtv_Mw.mjs';
+
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
+type DatabaseConfig = {
+    path?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+};
+interface RuntimeModuleOptions {
+    connector?: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables?: {
+        migrations?: string;
+        users?: string;
+        personalAccessTokens?: string;
+        passwordResetTokens?: string;
+    };
+    /**
+     * Mailer configuration options for sending emails (e.g., password resets)
+     * Uses nodemailer
+     */
+    mailer?: MailerOptions;
+    /**
+     * Base URL for password reset links
+     * @default 'http://localhost:3000' // Example, will be set in module defaults
+     */
+    passwordResetBaseUrl?: string;
+    /**
+     * Skip database checks during module setup to prevent hanging
+     * @default false
+     */
+    auth?: {
+        /**
+         * Whitelisted routes that do not require authentication
+         * @default ['/login']
+         * @example ['/login', '/register']
+         */
+        whitelist?: string[];
+    };
+    /**
+     * Password validation configuration
+     */
+    passwordValidation?: {
+        /**
+         * Minimum password length
+         * @default 8
+         */
+        minLength?: number;
+        /**
+         * Require uppercase letters
+         * @default true
+         */
+        requireUppercase?: boolean;
+        /**
+         * Require lowercase letters
+         * @default true
+         */
+        requireLowercase?: boolean;
+        /**
+         * Require numbers
+         * @default true
+         */
+        requireNumbers?: boolean;
+        /**
+         * Require special characters
+         * @default true
+         */
+        requireSpecialChars?: boolean;
+        /**
+         * Prevent common passwords
+         * @default true
+         */
+        preventCommonPasswords?: boolean;
+    };
+}
+interface ModuleOptions extends Omit<RuntimeModuleOptions, 'tables' | 'auth' | 'passwordValidation'> {
+    connector: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables: {
+        migrations: string;
+        users: string;
+        personalAccessTokens: string;
+        passwordResetTokens: string;
+    };
+    auth: {
+        whitelist: string[];
+    };
+    passwordValidation: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecialChars: boolean;
+        preventCommonPasswords: boolean;
+    };
+}
+interface MailerOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+    defaults?: {
+        from: string;
+    };
+}
 
 declare const defaultOptions: ModuleOptions;
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;

package/dist/module.d.ts

@@ -1,5 +1,118 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleOptions } from './shared/nuxt-users.CMEtv_Mw.js';
+
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
+type DatabaseConfig = {
+    path?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+};
+interface RuntimeModuleOptions {
+    connector?: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables?: {
+        migrations?: string;
+        users?: string;
+        personalAccessTokens?: string;
+        passwordResetTokens?: string;
+    };
+    /**
+     * Mailer configuration options for sending emails (e.g., password resets)
+     * Uses nodemailer
+     */
+    mailer?: MailerOptions;
+    /**
+     * Base URL for password reset links
+     * @default 'http://localhost:3000' // Example, will be set in module defaults
+     */
+    passwordResetBaseUrl?: string;
+    /**
+     * Skip database checks during module setup to prevent hanging
+     * @default false
+     */
+    auth?: {
+        /**
+         * Whitelisted routes that do not require authentication
+         * @default ['/login']
+         * @example ['/login', '/register']
+         */
+        whitelist?: string[];
+    };
+    /**
+     * Password validation configuration
+     */
+    passwordValidation?: {
+        /**
+         * Minimum password length
+         * @default 8
+         */
+        minLength?: number;
+        /**
+         * Require uppercase letters
+         * @default true
+         */
+        requireUppercase?: boolean;
+        /**
+         * Require lowercase letters
+         * @default true
+         */
+        requireLowercase?: boolean;
+        /**
+         * Require numbers
+         * @default true
+         */
+        requireNumbers?: boolean;
+        /**
+         * Require special characters
+         * @default true
+         */
+        requireSpecialChars?: boolean;
+        /**
+         * Prevent common passwords
+         * @default true
+         */
+        preventCommonPasswords?: boolean;
+    };
+}
+interface ModuleOptions extends Omit<RuntimeModuleOptions, 'tables' | 'auth' | 'passwordValidation'> {
+    connector: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables: {
+        migrations: string;
+        users: string;
+        personalAccessTokens: string;
+        passwordResetTokens: string;
+    };
+    auth: {
+        whitelist: string[];
+    };
+    passwordValidation: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecialChars: boolean;
+        preventCommonPasswords: boolean;
+    };
+}
+interface MailerOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+    defaults?: {
+        from: string;
+    };
+}
 
 declare const defaultOptions: ModuleOptions;
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-users",
   "configKey": "nuxtUsers",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "3.6.0"

package/dist/runtime/plugin.js

@@ -1,5 +1,5 @@
 import { addRouteMiddleware, defineNuxtPlugin, useRuntimeConfig, navigateTo } from "#app";
-import { checkTableExists } from "../utils";
+import { checkTableExists } from "./server/utils/index.js";
 import { useAuth } from "./composables/useAuth.js";
 export default defineNuxtPlugin(async (_nuxtApp) => {
   const { nuxtUsers } = useRuntimeConfig();

package/dist/runtime/server/api/login.post.js

@@ -2,7 +2,7 @@ import { createError, defineEventHandler, readBody, setCookie } from "h3";
 import bcrypt from "bcrypt";
 import crypto from "node:crypto";
 import { useRuntimeConfig } from "#imports";
-import { useDb } from "../../../utils";
+import { useDb } from "../utils/index.js";
 export default defineEventHandler(async (event) => {
   const body = await readBody(event);
   const { email, password } = body;

package/dist/runtime/server/api/logout.get.js

@@ -1,6 +1,6 @@
 import { defineEventHandler, getCookie, setCookie } from "h3";
 import { useRuntimeConfig } from "#imports";
-import { useDb } from "../../../utils";
+import { useDb } from "../utils/index.js";
 export default defineEventHandler(async (event) => {
   const { nuxtUsers } = useRuntimeConfig();
   const options = nuxtUsers;

package/dist/runtime/server/api/profile.get.js

@@ -1,6 +1,6 @@
 import { createError, defineEventHandler, getCookie } from "h3";
 import { useRuntimeConfig } from "#imports";
-import { getCurrentUserFromToken } from "../../../utils";
+import { getCurrentUserFromToken } from "../utils/index.js";
 export default defineEventHandler(async (event) => {
   const { nuxtUsers } = useRuntimeConfig();
   const options = nuxtUsers;

package/dist/runtime/server/api/update-password.post.js

@@ -1,7 +1,8 @@
 import { createError, defineEventHandler, getCookie, readBody } from "h3";
 import bcrypt from "bcrypt";
 import { useRuntimeConfig } from "#imports";
-import { getCurrentUserFromToken, updateUserPassword, validatePassword, getPasswordValidationOptions } from "../../../utils";
+import { getCurrentUserFromToken, updateUserPassword } from "../utils/index.js";
+import { validatePassword, getPasswordValidationOptions } from "../../../utils";
 export default defineEventHandler(async (event) => {
   const { nuxtUsers } = useRuntimeConfig();
   const options = nuxtUsers;

package/dist/runtime/server/services/password.js

@@ -1,7 +1,7 @@
 import { createTransport } from "nodemailer";
 import crypto from "node:crypto";
 import bcrypt from "bcrypt";
-import { findUserByEmail, updateUserPassword, useDb } from "../../../utils";
+import { findUserByEmail, updateUserPassword, useDb } from "../utils/index.js";
 const TOKEN_EXPIRATION_HOURS = 1;
 export const sendPasswordResetLink = async (email, options) => {
   const user = await findUserByEmail(email, options);

package/dist/runtime/server/utils/create-migrations-table.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;

package/dist/runtime/server/utils/create-migrations-table.js

@@ -0,0 +1,35 @@
+import { useDb } from "./db.js";
+export const createMigrationsTable = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(options);
+  const tableName = "migrations";
+  console.log(`[Nuxt Users] DB:Create Migrations ${connectorName} Table Creating ${tableName} table with ${connectorName} connector...`);
+  if (connectorName === "sqlite") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      executed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "mysql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        executed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  if (connectorName === "postgresql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  console.log(`[Nuxt Users] DB:Create Migrations ${connectorName} Table successfull \u2705`);
+};

package/dist/runtime/server/utils/create-password-reset-tokens-table.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const createPasswordResetTokensTable: (options: ModuleOptions) => Promise<void>;

package/dist/runtime/server/utils/create-password-reset-tokens-table.js

@@ -0,0 +1,40 @@
+import { useDb } from "./db.js";
+export const createPasswordResetTokensTable = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(options);
+  const tableName = options.tables.passwordResetTokens;
+  console.log(`[Nuxt Users] DB:Create Password Reset Tokens ${connectorName} Table Creating ${tableName} table with ${connectorName} connector...`);
+  if (connectorName === "sqlite") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      email TEXT NOT NULL,
+      token TEXT NOT NULL UNIQUE,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "mysql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        email VARCHAR(255) NOT NULL,
+        token VARCHAR(255) NOT NULL UNIQUE,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  if (connectorName === "postgresql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id SERIAL PRIMARY KEY,
+        email VARCHAR(255) NOT NULL,
+        token VARCHAR(255) NOT NULL UNIQUE,
+        created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  await db.sql`CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_email ON {${tableName}} (email)`;
+  await db.sql`CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_token ON {${tableName}} (token)`;
+  console.log(`[Nuxt Users] DB:Create Password Reset Tokens ${connectorName} Table Fields: id, email, token, created_at \u2705`);
+};

package/dist/runtime/server/utils/create-personal-access-tokens-table.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const createPersonalAccessTokensTable: (options: ModuleOptions) => Promise<void>;

package/dist/runtime/server/utils/create-personal-access-tokens-table.js

@@ -0,0 +1,56 @@
+import { useDb } from "./db.js";
+export const createPersonalAccessTokensTable = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(options);
+  const tableName = options.tables.personalAccessTokens;
+  console.log(`[Nuxt Users] DB:Create Personal Access Tokens ${connectorName} Table Creating ${tableName} table with ${connectorName} connector...`);
+  if (connectorName === "sqlite") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tokenable_type TEXT NOT NULL,
+      tokenable_id INTEGER NOT NULL,
+      name TEXT NOT NULL,
+      token TEXT NOT NULL UNIQUE,
+      abilities TEXT,
+      last_used_at DATETIME,
+      expires_at DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "mysql") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INT AUTO_INCREMENT PRIMARY KEY,
+      tokenable_type VARCHAR(255) NOT NULL,
+      tokenable_id INT NOT NULL,
+      name VARCHAR(255) NOT NULL,
+      token VARCHAR(255) NOT NULL UNIQUE,
+      abilities TEXT,
+      last_used_at DATETIME,
+      expires_at DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "postgresql") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id SERIAL PRIMARY KEY,
+      tokenable_type VARCHAR(255) NOT NULL,
+      tokenable_id INT NOT NULL,
+      name VARCHAR(255) NOT NULL,
+      token VARCHAR(255) NOT NULL UNIQUE,
+      abilities TEXT,
+      last_used_at TIMESTAMPTZ,
+      expires_at TIMESTAMPTZ,
+      created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  console.log(`[Nuxt Users] DB:Create Personal Access Tokens ${connectorName} Table Fields: id, tokenable_type, tokenable_id, name, token, abilities, last_used_at, expires_at, created_at, updated_at \u2705`);
+};

package/dist/runtime/server/utils/create-user.d.ts

@@ -0,0 +1 @@
+export { createUser } from './user.js';

package/dist/runtime/server/utils/create-user.js

@@ -0,0 +1 @@
+export { createUser } from "./user.js";

package/dist/runtime/server/utils/create-users-table.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const createUsersTable: (options: ModuleOptions) => Promise<void>;

package/dist/runtime/server/utils/create-users-table.js

@@ -0,0 +1,47 @@
+import { useDb } from "./db.js";
+export const createUsersTable = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(options);
+  const tableName = options.tables.users;
+  console.log(`[Nuxt Users] DB:Create ${connectorName} Users Table Creating ${tableName}...`);
+  if (connectorName === "sqlite") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      email TEXT NOT NULL UNIQUE,
+      name TEXT NOT NULL,
+      password TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'user',
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "mysql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        email VARCHAR(255) NOT NULL UNIQUE,
+        name VARCHAR(255) NOT NULL,
+        password VARCHAR(255) NOT NULL,
+        role VARCHAR(32) NOT NULL DEFAULT 'user',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  if (connectorName === "postgresql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id SERIAL PRIMARY KEY,
+        email VARCHAR(255) NOT NULL UNIQUE,
+        name VARCHAR(255) NOT NULL,
+        password VARCHAR(255) NOT NULL,
+        role VARCHAR(32) NOT NULL DEFAULT 'user',
+        created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  console.log(`[Nuxt Users] DB:Create ${connectorName} Users Table Fields: id, email, name, password, role, created_at, updated_at \u2705`);
+};

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

@@ -0,0 +1,4 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const getConnector: (name: string) => Promise<typeof import("db0/connectors/mysql2").default | typeof import("db0/connectors/postgresql").default | typeof import("db0/connectors/better-sqlite3").default>;
+export declare const useDb: (options: ModuleOptions) => Promise<import("db0").Database<import("db0").Connector<Database.Database>>>;
+export declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;

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

@@ -0,0 +1,46 @@
+import { createDatabase } from "db0";
+export const getConnector = async (name) => {
+  try {
+    switch (name) {
+      case "mysql":
+        return (await import("db0/connectors/mysql2")).default;
+      case "postgresql":
+        return (await import("db0/connectors/postgresql")).default;
+      case "sqlite":
+        return (await import("db0/connectors/better-sqlite3")).default;
+      default:
+        throw new Error(`Unsupported database connector: ${name}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot resolve")) {
+      throw new Error(`Database connector "${name}" not found. Please install the required peer dependency:
+- For sqlite: yarn add better-sqlite3
+- For mysql: yarn add mysql2
+- For postgresql: yarn add pg`);
+    }
+    throw error;
+  }
+};
+export const useDb = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const connectorOptions = { ...options.connector.options };
+  if (connectorName !== "sqlite") {
+    delete connectorOptions.path;
+  }
+  try {
+    return createDatabase(connector(connectorOptions));
+  } catch (error) {
+    console.warn(`[Nuxt Users] \u26A0\uFE0F  Failed to connect to ${connectorName} database:`, error instanceof Error ? error.message : "Unknown error");
+    throw error;
+  }
+};
+export const checkTableExists = async (options, tableName) => {
+  try {
+    const db = await useDb(options);
+    await db.sql`SELECT 1 FROM {${tableName}} LIMIT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+};

package/dist/runtime/server/utils/index.d.ts

@@ -0,0 +1,7 @@
+export { useDb, checkTableExists } from './db.js';
+export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers } from './user.js';
+export { createUsersTable } from './create-users-table.js';
+export { createPersonalAccessTokensTable } from './create-personal-access-tokens-table.js';
+export { createPasswordResetTokensTable } from './create-password-reset-tokens-table.js';
+export { createMigrationsTable } from './create-migrations-table.js';
+export { runMigrations } from './migrate.js';

package/dist/runtime/server/utils/index.js

@@ -0,0 +1,7 @@
+export { useDb, checkTableExists } from "./db.js";
+export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers } from "./user.js";
+export { createUsersTable } from "./create-users-table.js";
+export { createPersonalAccessTokensTable } from "./create-personal-access-tokens-table.js";
+export { createPasswordResetTokensTable } from "./create-password-reset-tokens-table.js";
+export { createMigrationsTable } from "./create-migrations-table.js";
+export { runMigrations } from "./migrate.js";

package/dist/runtime/server/utils/migrate.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const getAppliedMigrations: (options: ModuleOptions) => Promise<string[]>;
+export declare const markMigrationAsApplied: (options: ModuleOptions, migrationName: string) => Promise<void>;
+export declare const runMigrations: (options: ModuleOptions) => Promise<void>;