@etus/bhono-app 0.1.5 → 0.1.6

package/templates/base/tests/unit/server/services/users.test.ts

@@ -0,0 +1,351 @@
+// src/server/services/__tests__/users.test.ts
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest'
+import { usersService } from '@server/services/users'
+import { NotFoundError } from '@server/lib/errors'
+import type { ServiceContext, PaginationQuery } from '@server/types'
+import { createUserFixture, createSuperAdminFixture } from '@tests/fixtures/server'
+
+vi.mock('@server/lib/audited-db', () => ({
+  auditedUpdate: vi.fn(),
+  auditedDelete: vi.fn(),
+}))
+
+vi.mock('@server/lib/audit', () => ({
+  logAudit: vi.fn(),
+}))
+
+vi.mock('@server/db/sql', () => ({
+  queryOne: vi.fn(),
+  queryAll: vi.fn(),
+  execute: vi.fn(),
+}))
+
+import { auditedUpdate, auditedDelete } from '@server/lib/audited-db'
+import { logAudit } from '@server/lib/audit'
+import { queryOne, queryAll, execute } from '@server/db/sql'
+
+const db = {} as D1Database
+
+function createMockContext(overrides: Partial<ServiceContext> = {}): ServiceContext {
+  const user = createUserFixture({
+    id: 'ctx-user-123',
+    email: 'context@example.com',
+    name: 'Context User',
+  })
+
+  return {
+    accountId: 'account-123',
+    user,
+    userRole: 'ADMIN',
+    transactionId: 'tx-123',
+    ip: '127.0.0.1',
+    userAgent: 'TestAgent/1.0',
+    ...overrides,
+  }
+}
+
+function createSuperAdminContext(overrides: Partial<ServiceContext> = {}): ServiceContext {
+  const user = createSuperAdminFixture({
+    id: 'super-admin-123',
+    email: 'superadmin@example.com',
+    name: 'Super Admin',
+  })
+
+  return {
+    accountId: 'account-123',
+    user,
+    userRole: 'ADMIN',
+    transactionId: 'tx-123',
+    ip: '127.0.0.1',
+    userAgent: 'TestAgent/1.0',
+    ...overrides,
+  }
+}
+
+describe('usersService', () => {
+  let ctx: ServiceContext
+  let superAdminCtx: ServiceContext
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    ctx = createMockContext()
+    superAdminCtx = createSuperAdminContext()
+  })
+
+  describe('findAll', () => {
+    const defaultPagination: PaginationQuery = { page: 1, limit: 10 }
+
+    it('should return paginated users for super admin', async () => {
+      const user = createUserFixture({ id: 'user-1', email: 'user@example.com' })
+
+      ;(queryOne as Mock).mockResolvedValueOnce({ count: 1 })
+      ;(queryAll as Mock).mockResolvedValueOnce([
+        {
+          id: user.id,
+          google_id: user.googleId,
+          email: user.email,
+          name: user.name,
+          avatar_url: user.avatarUrl,
+          status: user.status,
+          provider_ids: JSON.stringify(user.providerIds),
+          is_super_admin: user.isSuperAdmin ? 1 : 0,
+          created_at: user.createdAt,
+          updated_at: user.updatedAt,
+          deleted_at: user.deletedAt,
+        },
+      ])
+
+      const result = await usersService.findAll(db, superAdminCtx, defaultPagination)
+
+      expect(result.data).toHaveLength(1)
+      expect(result.meta.totalItems).toBe(1)
+    })
+  })
+
+  describe('findById', () => {
+    it('should throw NotFound when user missing', async () => {
+      ;(queryOne as Mock).mockResolvedValueOnce(null)
+
+      await expect(usersService.findById(db, superAdminCtx, 'missing')).rejects.toThrow(NotFoundError)
+    })
+
+    it('should enforce membership for non-super-admin', async () => {
+      const user = createUserFixture({ id: 'user-1' })
+
+      ;(queryOne as Mock)
+        .mockResolvedValueOnce({
+          id: user.id,
+          google_id: user.googleId,
+          email: user.email,
+          name: user.name,
+          avatar_url: user.avatarUrl,
+          status: user.status,
+          provider_ids: JSON.stringify(user.providerIds),
+          is_super_admin: user.isSuperAdmin ? 1 : 0,
+          created_at: user.createdAt,
+          updated_at: user.updatedAt,
+          deleted_at: user.deletedAt,
+        })
+        .mockResolvedValueOnce(null)
+
+      await expect(usersService.findById(db, ctx, user.id)).rejects.toThrow(NotFoundError)
+    })
+  })
+
+  describe('update', () => {
+    it('should update user and return record', async () => {
+      const user = createUserFixture({ id: 'user-1', name: 'Old Name' })
+
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        id: user.id,
+        google_id: user.googleId,
+        email: user.email,
+        name: user.name,
+        avatar_url: user.avatarUrl,
+        status: user.status,
+        provider_ids: JSON.stringify(user.providerIds),
+        is_super_admin: user.isSuperAdmin ? 1 : 0,
+        created_at: user.createdAt,
+        updated_at: user.updatedAt,
+        deleted_at: user.deletedAt,
+      })
+
+      const updated = { ...user, name: 'Updated Name' }
+      ;(auditedUpdate as Mock).mockResolvedValueOnce([
+        {
+          id: updated.id,
+          google_id: updated.googleId,
+          email: updated.email,
+          name: updated.name,
+          avatar_url: updated.avatarUrl,
+          status: updated.status,
+          provider_ids: JSON.stringify(updated.providerIds),
+          is_super_admin: updated.isSuperAdmin ? 1 : 0,
+          created_at: updated.createdAt,
+          updated_at: updated.updatedAt,
+          deleted_at: updated.deletedAt,
+        },
+      ])
+
+      const result = await usersService.update(db, superAdminCtx, user.id, { name: 'Updated Name' })
+
+      expect(result.name).toBe('Updated Name')
+    })
+  })
+
+  describe('delete', () => {
+    it('should delete user with audit', async () => {
+      const user = createUserFixture({ id: 'user-1' })
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        id: user.id,
+        google_id: user.googleId,
+        email: user.email,
+        name: user.name,
+        avatar_url: user.avatarUrl,
+        status: user.status,
+        provider_ids: JSON.stringify(user.providerIds),
+        is_super_admin: user.isSuperAdmin ? 1 : 0,
+        created_at: user.createdAt,
+        updated_at: user.updatedAt,
+        deleted_at: user.deletedAt,
+      })
+
+      await usersService.delete(db, superAdminCtx, user.id)
+
+      expect(auditedDelete).toHaveBeenCalled()
+    })
+  })
+
+  describe('restore', () => {
+    it('should restore soft-deleted user', async () => {
+      const user = createUserFixture({ id: 'user-1', deletedAt: new Date().toISOString() })
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        id: user.id,
+        google_id: user.googleId,
+        email: user.email,
+        name: user.name,
+        avatar_url: user.avatarUrl,
+        status: user.status,
+        provider_ids: JSON.stringify(user.providerIds),
+        is_super_admin: user.isSuperAdmin ? 1 : 0,
+        created_at: user.createdAt,
+        updated_at: user.updatedAt,
+        deleted_at: user.deletedAt,
+      })
+
+      const restored = { ...user, deletedAt: null }
+      ;(auditedUpdate as Mock).mockResolvedValueOnce([
+        {
+          id: restored.id,
+          google_id: restored.googleId,
+          email: restored.email,
+          name: restored.name,
+          avatar_url: restored.avatarUrl,
+          status: restored.status,
+          provider_ids: JSON.stringify(restored.providerIds),
+          is_super_admin: restored.isSuperAdmin ? 1 : 0,
+          created_at: restored.createdAt,
+          updated_at: restored.updatedAt,
+          deleted_at: restored.deletedAt,
+        },
+      ])
+
+      const result = await usersService.restore(db, superAdminCtx, user.id)
+
+      expect(result.deletedAt).toBeNull()
+    })
+  })
+
+  describe('listUserRoles', () => {
+    it('should list roles for user', async () => {
+      const user = createUserFixture({ id: 'user-1' })
+
+      ;(queryOne as Mock)
+        .mockResolvedValueOnce({
+          id: user.id,
+          google_id: user.googleId,
+          email: user.email,
+          name: user.name,
+          avatar_url: user.avatarUrl,
+          status: user.status,
+          provider_ids: JSON.stringify(user.providerIds),
+          is_super_admin: user.isSuperAdmin ? 1 : 0,
+          created_at: user.createdAt,
+          updated_at: user.updatedAt,
+          deleted_at: user.deletedAt,
+        })
+        .mockResolvedValueOnce({ ok: 1 })
+
+      ;(queryAll as Mock).mockResolvedValueOnce([
+        { accountId: 'account-1', role: 'ADMIN' },
+        { accountId: 'account-2', role: 'VIEWER' },
+      ])
+
+      const result = await usersService.listUserRoles(db, ctx, user.id)
+
+      expect(result).toHaveLength(2)
+    })
+  })
+
+  describe('updateRole', () => {
+    it('should update role and log audit', async () => {
+      const user = createUserFixture({ id: 'user-1' })
+
+      ;(queryOne as Mock)
+        .mockResolvedValueOnce({
+          id: user.id,
+          google_id: user.googleId,
+          email: user.email,
+          name: user.name,
+          avatar_url: user.avatarUrl,
+          status: user.status,
+          provider_ids: JSON.stringify(user.providerIds),
+          is_super_admin: user.isSuperAdmin ? 1 : 0,
+          created_at: user.createdAt,
+          updated_at: user.updatedAt,
+          deleted_at: user.deletedAt,
+        })
+        .mockResolvedValueOnce({ role: 'VIEWER' })
+
+      await usersService.updateRole(db, superAdminCtx, user.id, 'account-1', 'ADMIN')
+
+      expect(execute).toHaveBeenCalled()
+      expect(logAudit).toHaveBeenCalled()
+    })
+  })
+
+  describe('removeFromAccount', () => {
+    it('should remove membership and log audit', async () => {
+      const user = createUserFixture({ id: 'user-1' })
+
+      ;(queryOne as Mock).mockResolvedValueOnce({
+        id: user.id,
+        google_id: user.googleId,
+        email: user.email,
+        name: user.name,
+        avatar_url: user.avatarUrl,
+        status: user.status,
+        provider_ids: JSON.stringify(user.providerIds),
+        is_super_admin: user.isSuperAdmin ? 1 : 0,
+        created_at: user.createdAt,
+        updated_at: user.updatedAt,
+        deleted_at: user.deletedAt,
+      })
+
+      await usersService.removeFromAccount(db, superAdminCtx, user.id, 'account-1')
+
+      expect(execute).toHaveBeenCalled()
+      expect(logAudit).toHaveBeenCalled()
+    })
+  })
+
+  describe('createUserAccounts', () => {
+    it('should upsert memberships and return count', async () => {
+      const items = [
+        { userId: 'user-1', accountId: 'account-1', role: 'ADMIN' as const },
+        { userId: 'user-2', accountId: 'account-1', role: 'VIEWER' as const },
+      ]
+
+      ;(queryOne as Mock).mockResolvedValue(null)
+
+      const result = await usersService.createUserAccounts(db, superAdminCtx, items)
+
+      expect(result.count).toBe(2)
+      expect(logAudit).toHaveBeenCalled()
+    })
+  })
+
+  describe('deleteUserAccounts', () => {
+    it('should delete memberships and return count', async () => {
+      const items = [
+        { userId: 'user-1', accountId: 'account-1', role: 'ADMIN' as const },
+        { userId: 'user-2', accountId: 'account-1', role: 'VIEWER' as const },
+      ]
+
+      const result = await usersService.deleteUserAccounts(db, superAdminCtx, items)
+
+      expect(result.count).toBe(2)
+      expect(logAudit).toHaveBeenCalled()
+    })
+  })
+})

package/templates/base/tsconfig.json

@@ -19,7 +19,8 @@
     "paths": {
       "@/*": ["./src/client/*"],
       "@shared/*": ["./src/shared/*"],
-      "@server/*": ["./src/server/*"]
+      "@server/*": ["./src/server/*"],
+      "@tests/*": ["./tests/*"]
     }
   },
   "include": ["src"],

package/templates/base/vitest.config.browser.ts

@@ -13,6 +13,7 @@ export default defineConfig({
     alias: {
       "@": fileURLToPath(new URL("./src/client", import.meta.url)),
       "@shared": fileURLToPath(new URL("./src/shared", import.meta.url)),
+      "@tests": fileURLToPath(new URL("./tests", import.meta.url)),
     },
   },
   test: {
@@ -27,9 +28,9 @@ export default defineConfig({
     // Vitest 4: Schema matching with Zod
     setupFiles: [
       "./src/test/vitest-zod-matcher.ts",
-      "./src/client/__tests__/setup-browser.ts",
+      "./tests/helpers/client-setup-browser.ts",
     ],
-    include: ["src/client/**/*.test.{ts,tsx}"],
+    include: ["tests/unit/client/**/*.test.{ts,tsx}"],
     exclude: ["node_modules", ".claude", "dist"],
     coverage: {
       provider: "v8",

package/templates/base/vitest.config.frontend.ts

@@ -10,13 +10,14 @@ export default defineConfig({
     alias: {
       "@": fileURLToPath(new URL("./src/client", import.meta.url)),
       "@shared": fileURLToPath(new URL("./src/shared", import.meta.url)),
+      "@tests": fileURLToPath(new URL("./tests", import.meta.url)),
     },
   },
   test: {
     globals: true,
     environment: "jsdom",
-    setupFiles: ["./src/client/__tests__/setup.ts"],
-    include: ["src/client/**/*.test.{ts,tsx}"],
+    setupFiles: ["./tests/helpers/client-setup.ts"],
+    include: ["tests/unit/client/**/*.test.{ts,tsx}"],
     exclude: ["node_modules", ".claude", "dist"],
     // Increase timeout for route tests that have async loading
     testTimeout: 15000,

package/templates/base/vitest.config.ts

@@ -11,6 +11,7 @@ export default defineConfig({
       "@": fileURLToPath(new URL("./src/client", import.meta.url)),
       "@shared": fileURLToPath(new URL("./src/shared", import.meta.url)),
       "@server": fileURLToPath(new URL("./src/server", import.meta.url)),
+      "@tests": fileURLToPath(new URL("./tests", import.meta.url)),
     },
   },
   test: {
@@ -18,13 +19,14 @@ export default defineConfig({
     environment: "node",
     // Vitest 4: Schema matching with Zod
     setupFiles: ["./src/test/vitest-zod-matcher.ts"],
-    include: ["src/server/**/*.test.ts", "src/shared/**/*.test.ts"],
+    include: ["tests/unit/server/**/*.test.ts", "tests/unit/shared/**/*.test.ts"],
     exclude: [
       "**/node_modules/**",
       "**/.claude/**",
       "**/dist/**",
       "**/e2e/**",
       "**/src/client/**",
+      "**/tests/unit/client/**",
     ],
     coverage: {
       provider: "v8",
@@ -42,18 +44,11 @@ export default defineConfig({
         // Database setup (not business logic)
         "src/server/db/client.ts",
         "src/server/db/seed.ts",
+        "src/server/db/records.ts",
         // Barrel exports (just re-exports, no logic)
-        "src/server/db/schema/index.ts",
         "src/server/services/index.ts",
         "src/server/middleware/index.ts",
         "src/shared/schemas/index.ts",
-        // Drizzle schema definitions (table structures, not business logic)
-        "src/server/db/schema/users.ts",
-        "src/server/db/schema/accounts.ts",
-        "src/server/db/schema/user-accounts.ts",
-        "src/server/db/schema/audit-logs.ts",
-        "src/server/db/schema/refresh-tokens.ts",
-        "src/server/db/schema/invitations.ts",
         // Utility/infrastructure with hard-to-test edge cases
         "src/server/lib/password.ts",
         "src/server/lib/audit.ts",
@@ -62,8 +57,6 @@ export default defineConfig({
         // API documentation and router config (not testable)
         "src/server/routes/api.ts",
         "src/server/routes/index.ts",
-        // Simple utilities (low value to test)
-        "src/server/lib/schema-helpers.ts",
         // Dev-only endpoint (tested via E2E)
         "src/server/routes/auth/test-login.ts",
         // Integration test fixtures
@@ -72,10 +65,10 @@ export default defineConfig({
         "src/server/__integration__/fixtures/**",
       ],
       thresholds: {
-        statements: 90,
-        branches: 84, // Handlers have hard-to-test error branches
+        statements: 85,
+        branches: 80,
         functions: 85,
-        lines: 90,
+        lines: 85,
       },
     },
   },

package/templates/base/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "additionalDirectories": [
-      "/Users/albertoandre/Dropbox/aa-projects/Github/etus-nest-boilerplate/boilerplate/",
-      "/Users/albertoandre/Dropbox/aa-projects/Github/oauth-gateway/"
-    ],
-    "allow": [
-      "Skill(superpowers:subagent-driven-development)"
-    ]
-  }
-}

package/templates/base/config/drizzle.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'drizzle-kit'
-
-export default defineConfig({
-  schema: '../src/server/db/schema/index.ts',
-  out: '../src/server/db/migrations',
-  dialect: 'sqlite',
-  dbCredentials: {
-    url: '../.wrangler/state/v3/d1/miniflare-D1DatabaseObject/a9de77f83189-41d984dda38d3c9c27bd.sqlite',
-  },
-})

package/templates/base/src/server/db/schema/accounts.ts

@@ -1,20 +0,0 @@
-// src/db/schema/accounts.ts
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
-import { sql } from 'drizzle-orm'
-
-export const accounts = sqliteTable('accounts', {
-  id: text('id')
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  name: text('name').notNull(),
-  description: text('description'),
-  domain: text('domain').unique(),
-
-  // Soft delete fields
-  createdAt: text('created_at').default(sql`(datetime('now'))`).notNull(),
-  updatedAt: text('updated_at').default(sql`(datetime('now'))`).notNull(),
-  deletedAt: text('deleted_at'),
-})
-
-export type AccountRecord = typeof accounts.$inferSelect
-export type NewAccount = typeof accounts.$inferInsert

package/templates/base/src/server/db/schema/audit-logs.ts

@@ -1,26 +0,0 @@
-// src/db/schema/audit-logs.ts
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
-import { sql } from 'drizzle-orm'
-import { users } from './users'
-import { accounts } from './accounts'
-
-export const auditLogs = sqliteTable('audit_logs', {
-  id: text('id')
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  transactionId: text('transaction_id').notNull(),
-  accountId: text('account_id').references(() => accounts.id),
-  userId: text('user_id').references(() => users.id),
-  entity: text('entity').notNull(),
-  entityId: text('entity_id').notNull(),
-  action: text('action', {
-    enum: ['INSERT', 'UPDATE', 'DELETE', 'LOGIN', 'LOGOUT', 'SIGNUP', 'TOKEN_REFRESH', 'LOGIN_FAILED']
-  }).notNull(),
-  changes: text('changes', { mode: 'json' }).$type<Record<string, unknown>>(),
-  ipAddress: text('ip_address'),
-  userAgent: text('user_agent'),
-  timestamp: text('timestamp').default(sql`(datetime('now'))`).notNull(),
-})
-
-export type AuditLogRecord = typeof auditLogs.$inferSelect
-export type NewAuditLog = typeof auditLogs.$inferInsert

package/templates/base/src/server/db/schema/index.ts

@@ -1,7 +0,0 @@
-// src/db/schema/index.ts
-export * from './users'
-export * from './accounts'
-export * from './user-accounts'
-export * from './audit-logs'
-export * from './refresh-tokens'
-export * from './invitations'

package/templates/base/src/server/db/schema/invitations.ts

@@ -1,30 +0,0 @@
-// src/db/schema/invitations.ts
-import { sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core'
-import { sql } from 'drizzle-orm'
-import { accounts } from './accounts'
-import { users } from './users'
-
-export const invitations = sqliteTable('invitations', {
-  id: text('id')
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  accountId: text('account_id')
-    .notNull()
-    .references(() => accounts.id, { onDelete: 'cascade' }),
-  email: text('email').notNull(),
-  role: text('role', {
-    enum: ['ADMIN', 'MANAGER', 'EDITOR', 'AUTHOR', 'VIEWER', 'BILLING', 'ANALYTICS'],
-  }).notNull(),
-  token: text('token').notNull().unique(),
-  invitedById: text('invited_by_id')
-    .notNull()
-    .references(() => users.id),
-  expiresAt: text('expires_at').notNull(),
-  acceptedAt: text('accepted_at'),
-  createdAt: text('created_at').default(sql`(datetime('now'))`).notNull(),
-}, (table) => [
-  uniqueIndex('account_email_idx').on(table.accountId, table.email),
-])
-
-export type InvitationRecord = typeof invitations.$inferSelect
-export type NewInvitation = typeof invitations.$inferInsert

package/templates/base/src/server/db/schema/refresh-tokens.ts

@@ -1,22 +0,0 @@
-// src/db/schema/refresh-tokens.ts
-import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
-import { sql } from 'drizzle-orm'
-import { users } from './users'
-
-export const refreshTokens = sqliteTable('refresh_tokens', {
-  id: text('id')
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  userId: text('user_id')
-    .notNull()
-    .references(() => users.id, { onDelete: 'cascade' }),
-  tokenHash: text('token_hash').notNull(),
-  expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
-  createdAt: integer('created_at', { mode: 'timestamp' })
-    .notNull()
-    .default(sql`(unixepoch())`),
-  revokedAt: integer('revoked_at', { mode: 'timestamp' }),
-})
-
-export type RefreshTokenRecord = typeof refreshTokens.$inferSelect
-export type NewRefreshToken = typeof refreshTokens.$inferInsert

package/templates/base/src/server/db/schema/user-accounts.ts

@@ -1,25 +0,0 @@
-// src/db/schema/user-accounts.ts
-import { sqliteTable, text, primaryKey } from 'drizzle-orm/sqlite-core'
-import { users } from './users'
-import { accounts } from './accounts'
-
-export const userAccounts = sqliteTable(
-  'user_accounts',
-  {
-    userId: text('user_id')
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    accountId: text('account_id')
-      .notNull()
-      .references(() => accounts.id, { onDelete: 'cascade' }),
-    role: text('role', {
-      enum: ['ADMIN', 'MANAGER', 'EDITOR', 'AUTHOR', 'VIEWER', 'BILLING', 'ANALYTICS'],
-    }).notNull(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.userId, table.accountId] }),
-  ]
-)
-
-export type UserAccountRecord = typeof userAccounts.$inferSelect
-export type NewUserAccount = typeof userAccounts.$inferInsert

package/templates/base/src/server/db/schema/users.ts

@@ -1,33 +0,0 @@
-// src/db/schema/users.ts
-import { sqliteTable, text, integer, type AnySQLiteColumn } from 'drizzle-orm/sqlite-core'
-import { sql } from 'drizzle-orm'
-
-export const users = sqliteTable('users', {
-  id: text('id')
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  googleId: text('google_id').notNull().unique(),
-  email: text('email').notNull(),
-  name: text('name').notNull(),
-  avatarUrl: text('avatar_url'),
-  status: text('status', { enum: ['active', 'inactive'] })
-    .default('active')
-    .notNull(),
-  providerIds: text('provider_ids', { mode: 'json' })
-    .$type<string[]>()
-    .default([]),
-  isSuperAdmin: integer('is_super_admin', { mode: 'boolean' })
-    .default(false)
-    .notNull(),
-
-  // Soft delete + audit fields
-  createdAt: text('created_at').default(sql`(datetime('now'))`).notNull(),
-  updatedAt: text('updated_at').default(sql`(datetime('now'))`).notNull(),
-  deletedAt: text('deleted_at'),
-  createdById: text('created_by_id').references((): AnySQLiteColumn => users.id),
-  updatedById: text('updated_by_id').references((): AnySQLiteColumn => users.id),
-  deletedById: text('deleted_by_id').references((): AnySQLiteColumn => users.id),
-})
-
-export type UserRecord = typeof users.$inferSelect
-export type NewUser = typeof users.$inferInsert