diff --git a/apps/blog-next/app/auth-nav.tsx b/apps/blog-next/app/auth-nav.tsx
index 91416f08..e2c5f7a9 100644
--- a/apps/blog-next/app/auth-nav.tsx
+++ b/apps/blog-next/app/auth-nav.tsx
@@ -1,9 +1,8 @@
'use client'
-import { useState } from 'react'
import Link from 'next/link'
-import { useRouter } from 'next/navigation'
import { useAuth } from '@holo-js/auth/next/client'
+import { logoutAction } from './logout/actions'
const linkStyle = {
color: '#cbd5e1',
@@ -25,37 +24,8 @@ const logoutFormStyle = {
export function AuthNav() {
const auth = useAuth()
- const router = useRouter()
- const [isLoggingOut, setIsLoggingOut] = useState(false)
const displayName = auth.user?.name ?? auth.user?.email ?? 'Account'
- async function logout() {
- if (isLoggingOut) {
- return
- }
-
- setIsLoggingOut(true)
- try {
- const response = await fetch('/api/logout', { method: 'POST' })
- if (!response.ok) {
- console.warn('Logout failed.', { status: response.status })
- return
- }
-
- try {
- await auth.refreshUser()
- } catch (error) {
- console.warn('Auth refresh failed after logout.', error)
- }
-
- router.replace('/')
- } catch (error) {
- console.warn('Logout failed.', error)
- } finally {
- setIsLoggingOut(false)
- }
- }
-
if (!auth.authenticated) {
return (
<>
@@ -68,7 +38,9 @@ export function AuthNav() {
return (
<>
{displayName}
-
+
{auth.provider === 'workos' && (
- {form.lastSubmission?.ok === true ? (
-
-
Signed in successfully.
-
Continue to admin
-
- Create account
+ Create account
Forgot password?
diff --git a/apps/blog-next/app/logout/actions.ts b/apps/blog-next/app/logout/actions.ts
new file mode 100644
index 00000000..6f7c5cc4
--- /dev/null
+++ b/apps/blog-next/app/logout/actions.ts
@@ -0,0 +1,11 @@
+'use server'
+
+import { logout } from '@holo-js/auth'
+import { revalidatePath } from 'next/cache'
+import { redirect } from 'next/navigation'
+
+export async function logoutAction() {
+ await logout()
+ revalidatePath('/', 'layout')
+ redirect('/')
+}
diff --git a/apps/blog-next/app/register/actions.ts b/apps/blog-next/app/register/actions.ts
new file mode 100644
index 00000000..7b7e973f
--- /dev/null
+++ b/apps/blog-next/app/register/actions.ts
@@ -0,0 +1,35 @@
+'use server'
+
+import { loginUsing, register } from '@holo-js/auth'
+import { validate } from '@holo-js/forms'
+import { revalidatePath } from 'next/cache'
+import { redirect } from 'next/navigation'
+
+import { registerForm } from '@/lib/schemas/auth'
+
+export async function registerAction(formData: FormData) {
+ const submission = await validate(formData, registerForm, {
+ csrf: true,
+ throttle: 'register',
+ })
+
+ if (!submission.valid) {
+ return submission.fail()
+ }
+
+ const { data: created, error } = await register(submission.data)
+ if (error) {
+ return submission.fail({
+ status: error.status,
+ errors: error.fields,
+ })
+ }
+
+ const session = await loginUsing(created)
+ const redirectTo = session.emailVerificationRequired
+ ? session.emailVerificationRoute ?? '/verify-email'
+ : '/admin'
+
+ revalidatePath('/', 'layout')
+ redirect(redirectTo)
+}
diff --git a/apps/blog-next/app/register/page.tsx b/apps/blog-next/app/register/page.tsx
index 9c1dbe7d..71a2ff87 100644
--- a/apps/blog-next/app/register/page.tsx
+++ b/apps/blog-next/app/register/page.tsx
@@ -1,11 +1,11 @@
'use client'
import Link from 'next/link'
-import { useRouter } from 'next/navigation'
import { useForm } from '@holo-js/adapter-next/client'
import { registerForm } from '@/lib/schemas/auth'
+import { registerAction } from './actions'
const panelStyle = {
display: 'grid',
@@ -18,18 +18,12 @@ const panelStyle = {
} satisfies React.CSSProperties
export default function RegisterPage() {
- const router = useRouter()
const form = useForm(registerForm, {
csrf: true,
validateOn: 'blur',
initialValues: { name: '', email: '', password: '', passwordConfirmation: '' },
async submitter({ formData }) {
- const response = await fetch('/api/register', { method: 'POST', body: formData })
- const submission = await response.json()
- if (submission?.ok === true) {
- router.replace('/login')
- }
- return submission
+ return await registerAction(formData)
},
})
@@ -93,13 +87,6 @@ export default function RegisterPage() {
- {form.lastSubmission?.ok === true ? (
-
-
Account created. Check your inbox to verify your email address.
-
Return to sign in
-
-
Signed in as super admin.
-
@@ -57,7 +24,9 @@
{#if auth.authenticated}
{displayName}
{#if !usesHostedLogout}
-
+
{/if}
{#if auth.provider === 'workos'}
Create account
Forgot password?
@@ -101,6 +90,5 @@
.social-links a { color: #e5e7eb; text-decoration: none; }
.remember, .links { display: flex; gap: 0.75rem; align-items: center; flex-wrap: wrap; }
.error { color: #fca5a5; }
- .success { color: #86efac; }
- .success a, .links a { color: #7dd3fc; text-decoration: none; }
+ .links a { color: #7dd3fc; text-decoration: none; }
diff --git a/apps/blog-sveltekit/src/routes/logout/+server.ts b/apps/blog-sveltekit/src/routes/logout/+server.ts
new file mode 100644
index 00000000..987aee1d
--- /dev/null
+++ b/apps/blog-sveltekit/src/routes/logout/+server.ts
@@ -0,0 +1,7 @@
+import { redirect } from '@sveltejs/kit'
+import { logout } from '@holo-js/auth'
+
+export async function POST() {
+ await logout()
+ redirect(303, '/')
+}
diff --git a/apps/blog-sveltekit/src/routes/register/+page.server.ts b/apps/blog-sveltekit/src/routes/register/+page.server.ts
new file mode 100644
index 00000000..cce5ee30
--- /dev/null
+++ b/apps/blog-sveltekit/src/routes/register/+page.server.ts
@@ -0,0 +1,35 @@
+import { fail, redirect } from '@sveltejs/kit'
+import { loginUsing, register } from '@holo-js/auth'
+import { validate } from '@holo-js/forms'
+
+import { registerForm } from '$lib/schemas/auth'
+import type { Actions } from './$types'
+
+export const actions = {
+ default: async ({ request }) => {
+ const submission = await validate(request, registerForm, {
+ csrf: true,
+ throttle: 'register',
+ })
+
+ if (!submission.valid) {
+ const failure = submission.fail()
+ return fail(failure.status, failure)
+ }
+
+ const { data: created, error } = await register(submission.data)
+ if (error) {
+ const failure = submission.fail({
+ status: error.status,
+ errors: error.fields,
+ })
+
+ return fail(failure.status, failure)
+ }
+
+ const session = await loginUsing(created)
+ redirect(303, session.emailVerificationRequired
+ ? session.emailVerificationRoute ?? '/verify-email'
+ : '/admin')
+ },
+} satisfies Actions
diff --git a/apps/blog-sveltekit/src/routes/register/+page.svelte b/apps/blog-sveltekit/src/routes/register/+page.svelte
index 4b9a9d6a..0ff81ea2 100644
--- a/apps/blog-sveltekit/src/routes/register/+page.svelte
+++ b/apps/blog-sveltekit/src/routes/register/+page.svelte
@@ -1,25 +1,15 @@
@@ -28,17 +18,23 @@
Create a local user account and verify the email address before signing in.
-
- {#if form.lastSubmission?.ok === true}
-
-
Account created. Check your inbox to verify your email address.
-
Return to sign in
-
Super Admin
Signed in as {displayName} through the admin guard.
-
+
diff --git a/apps/blog-sveltekit/src/routes/super-admin/login/+page.server.ts b/apps/blog-sveltekit/src/routes/super-admin/login/+page.server.ts
new file mode 100644
index 00000000..de0bc330
--- /dev/null
+++ b/apps/blog-sveltekit/src/routes/super-admin/login/+page.server.ts
@@ -0,0 +1,34 @@
+import { fail, redirect } from '@sveltejs/kit'
+import auth from '@holo-js/auth'
+import { validate } from '@holo-js/forms'
+
+import { loginForm } from '$lib/schemas/auth'
+import type { Actions } from './$types'
+
+export const actions = {
+ default: async ({ request }) => {
+ const submission = await validate(request, loginForm, {
+ csrf: true,
+ throttle: 'login',
+ })
+
+ if (!submission.valid) {
+ const failure = submission.fail()
+ return fail(failure.status, failure)
+ }
+
+ const { data: session, error } = await auth.guard('admin').login(submission.data)
+ if (error) {
+ const failure = submission.fail({
+ status: error.status,
+ errors: error.fields,
+ })
+
+ return fail(failure.status, failure)
+ }
+
+ redirect(303, session.emailVerificationRequired
+ ? session.emailVerificationRoute ?? '/verify-email'
+ : '/super-admin')
+ },
+} satisfies Actions
diff --git a/apps/blog-sveltekit/src/routes/super-admin/login/+page.svelte b/apps/blog-sveltekit/src/routes/super-admin/login/+page.svelte
index 79c4a154..972620af 100644
--- a/apps/blog-sveltekit/src/routes/super-admin/login/+page.svelte
+++ b/apps/blog-sveltekit/src/routes/super-admin/login/+page.svelte
@@ -1,21 +1,15 @@
@@ -24,18 +18,24 @@
Use a super admin account to access the super admin area.
-
-
- {#if form.lastSubmission?.ok === true}
-
-
Signed in as super admin.
-
{form.lastSubmission.data.message}
: null}
)
}
@@ -323,8 +347,11 @@ const form = useForm(loginForm, {
initialValues: { email: '', password: '', remember: false },
async submitter({ formData }) {
const submission = await $fetch('/api/login', { method: 'POST', body: formData })
- if (submission?.ok === true) {
+ if (submission?.ok === true && typeof submission.data?.redirectTo === 'string') {
await refreshUser()
+ await navigateTo(submission.data.redirectTo, {
+ external: true,
+ })
}
return submission
@@ -354,102 +381,72 @@ const form = useForm(loginForm, {
```
-```svelte [SvelteKit — src/routes/login/+page.svelte (useForm client)]
-
+Bind displayed values from `form.values.*` across frameworks and keep `form.fields.*` for field lifecycle helpers.
+`form.fields.email.onBlur()` is the blur-validation hook when `validateOn: 'blur'` is enabled, while touched
+state can also be set during input and value updates through helpers like `form.fields.email.onInput(...)`
+and `form.setValue(...)`.
-
+ redirect(303, session.emailVerificationRequired ? session.emailVerificationRoute ?? '/verify-email' : '/admin')
+ },
+}
```
-Bind displayed values from `form.values.*` across frameworks and keep `form.fields.*` for field lifecycle helpers.
-`form.fields.email.onBlur()` is the blur-validation hook when `validateOn: 'blur'` is enabled, while touched
-state can also be set during input and value updates through helpers like `form.fields.email.onInput(...)`
-and `form.setValue(...)`.
-
-```svelte [SvelteKit — src/routes/login/+page.svelte (form actions)]
+```svelte [SvelteKit — src/routes/login/+page.svelte]
-
```
@@ -565,6 +562,7 @@ export default defineEventHandler(async (event) => {
```
```ts [SvelteKit — src/routes/register/+page.server.ts]
+import { fail, redirect } from '@sveltejs/kit'
import { field, schema, validate } from '@holo-js/forms'
const registerUser = schema({
@@ -582,12 +580,13 @@ export const actions = {
})
if (!submission.valid) {
- return submission.fail()
+ const failure = submission.fail()
+ return fail(failure.status, failure)
}
await auth.register(submission.data)
- return submission.success({ message: 'Account created.' })
+ redirect(303, '/admin')
},
}
```
@@ -660,6 +659,7 @@ export default defineEventHandler(async (event) => {
```
```ts [SvelteKit — src/routes/avatar/+page.server.ts]
+import { fail } from '@sveltejs/kit'
import { field, schema, validate } from '@holo-js/forms'
const uploadAvatar = schema({
@@ -671,7 +671,8 @@ export const actions = {
const submission = await validate(request, uploadAvatar)
if (!submission.valid) {
- return submission.fail()
+ const failure = submission.fail()
+ return fail(failure.status, failure)
}
await media.store(submission.data.avatar)
diff --git a/apps/docs/docs/security.md b/apps/docs/docs/security.md
index e9a25455..84e322ad 100644
--- a/apps/docs/docs/security.md
+++ b/apps/docs/docs/security.md
@@ -307,7 +307,9 @@ const field = await csrf.field(request)
### Setting the readable cookie
-`useForm(..., { csrf: true })` needs the CSRF cookie to already exist:
+`useForm(..., { csrf: true })` needs the CSRF cookie to already exist. In the Next.js, Nuxt, and
+SvelteKit auth/framework integrations, the route protection hooks create this cookie before guest pages
+render. Use `csrf.cookie(request)` directly only for custom server-rendered HTML outside those helpers:
```ts
import { csrf } from '@holo-js/security'
diff --git a/bun.lock b/bun.lock
index c986fadc..bd2a7886 100644
--- a/bun.lock
+++ b/bun.lock
@@ -470,7 +470,6 @@
"version": "0.1.4",
"dependencies": {
"@holo-js/auth-social": "catalog:",
- "@holo-js/config": "catalog:",
},
"devDependencies": {
"@types/node": "catalog:",
@@ -726,8 +725,6 @@
"@holo-js/db-mysql": "catalog:",
"@holo-js/db-postgres": "catalog:",
"@holo-js/db-sqlite": "catalog:",
- "@types/better-sqlite3": "catalog:",
- "@types/pg": "catalog:",
"tsup": "catalog:",
"typescript": "catalog:",
},
diff --git a/packages/adapter-sveltekit/src/client.ts b/packages/adapter-sveltekit/src/client.ts
index 6c3f54dc..779fafbc 100644
--- a/packages/adapter-sveltekit/src/client.ts
+++ b/packages/adapter-sveltekit/src/client.ts
@@ -7,6 +7,8 @@ import {
createFormClient,
} from '@holo-js/forms/internal/client'
+type InitialFormState = UseFormOptions['initialState']
+
export {
type ClientSubmitContext,
type ClientSubmitResult,
@@ -25,6 +27,79 @@ function isPlainObject(value: unknown): value is Record {
&& !(value instanceof Blob)
}
+function isSchemaField(value: unknown): boolean {
+ return isPlainObject(value)
+ && value.kind === 'field'
+ && isPlainObject(value.definition)
+}
+
+function collectSchemaPaths(value: unknown, prefix = ''): readonly string[] {
+ if (isSchemaField(value)) {
+ return [prefix].filter(Boolean)
+ }
+
+ if (!isPlainObject(value)) {
+ return []
+ }
+
+ return Object.entries(value).flatMap(([key, nested]) => {
+ const next = prefix ? `${prefix}.${key}` : key
+ return collectSchemaPaths(nested, next)
+ })
+}
+
+function collectValuePaths(value: unknown, prefix = ''): readonly string[] {
+ if (!isPlainObject(value)) {
+ return [prefix].filter(Boolean)
+ }
+
+ return Object.entries(value).flatMap(([key, nested]) => {
+ const next = prefix ? `${prefix}.${key}` : key
+ return collectValuePaths(nested, next)
+ })
+}
+
+function isFormState(value: unknown): value is NonNullable> {
+ return isPlainObject(value)
+ && typeof value.valid === 'boolean'
+ && isPlainObject(value.values)
+ && isPlainObject(value.errors)
+}
+
+function stateMatchesSchema(schemaDefinition: FormSchema, state: NonNullable>): boolean {
+ const schemaPaths = collectSchemaPaths(schemaDefinition.fields)
+ const statePaths = [
+ ...Object.keys(state.errors),
+ ...collectValuePaths(state.values),
+ ]
+
+ return statePaths.every(path => path === '_root' || schemaPaths.includes(path))
+}
+
+async function hydrateActionFormState(
+ form: Pick, 'applyServerState'>,
+ schemaDefinition: FormSchema,
+): Promise {
+ if (typeof (globalThis as { readonly window?: unknown }).window === 'undefined') {
+ return
+ }
+
+ const stores = await import('$app/stores') as {
+ readonly page: {
+ subscribe(listener: (value: { readonly form: unknown }) => void): () => void
+ }
+ }
+ let unsubscribe = () => {}
+ unsubscribe = stores.page.subscribe((value) => {
+ const state = value.form
+ if (isFormState(state) && stateMatchesSchema(schemaDefinition, state)) {
+ form.applyServerState(state)
+ }
+
+ queueMicrotask(unsubscribe)
+ })
+}
+
function createReactiveView(
target: TValue,
subscribe: () => void,
@@ -86,8 +161,13 @@ export function useForm(
options: UseFormOptions, TSuccess> = {},
): UseFormResult, TSuccess, InferFormFieldTree> {
type TData = InferFormData
+ const formOptions: UseFormOptions = {
+ ...options,
+ initialState: options.initialState ?? undefined,
+ }
- const form = createFormClient(schemaDefinition, options)
+ const form = createFormClient(schemaDefinition, formOptions)
+ void hydrateActionFormState(form, schemaDefinition)
const subscribe = createSubscriber((update) => form.subscribe(update))
const cache = new WeakMap()
diff --git a/packages/adapter-sveltekit/src/sveltekit-app.d.ts b/packages/adapter-sveltekit/src/sveltekit-app.d.ts
new file mode 100644
index 00000000..82cb0c82
--- /dev/null
+++ b/packages/adapter-sveltekit/src/sveltekit-app.d.ts
@@ -0,0 +1,7 @@
+declare module '$app/stores' {
+ import type { Readable } from 'svelte/store'
+
+ export const page: Readable<{
+ readonly form: unknown
+ }>
+}
diff --git a/packages/adapter-sveltekit/tests/client.test.ts b/packages/adapter-sveltekit/tests/client.test.ts
index 310d7e4f..cf45fd83 100644
--- a/packages/adapter-sveltekit/tests/client.test.ts
+++ b/packages/adapter-sveltekit/tests/client.test.ts
@@ -1,114 +1,81 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import { field, schema } from '@holo-js/forms'
-const subscriberCleanups: Array<() => void> = []
+import { useForm } from '../src/client'
+import { setPageForm } from './stubs/app-stores'
-function cleanupSubscribers(): void {
- for (const cleanup of subscriberCleanups.splice(0)) {
- cleanup()
- }
+async function waitForActionHydration(): Promise {
+ await new Promise(resolve => setTimeout(resolve, 0))
+ await new Promise(resolve => queueMicrotask(() => resolve()))
}
-vi.mock('svelte/reactivity', () => ({
- createSubscriber(start: (update: () => void) => void | (() => void)) {
- let initialized = false
-
- return () => {
- if (!initialized) {
- const cleanup = start(() => {})
- if (cleanup) {
- subscriberCleanups.push(cleanup)
- }
- initialized = true
- }
- }
- },
-}))
-
-describe('@holo-js/adapter-sveltekit client', () => {
+describe('@holo-js/adapter-sveltekit client forms', () => {
afterEach(() => {
- cleanupSubscribers()
- vi.resetModules()
- vi.clearAllMocks()
- vi.doUnmock('svelte')
+ vi.unstubAllGlobals()
+ setPageForm(null)
})
- it('wraps the shared form client with a Svelte reactive subscriber bridge', async () => {
- const { useForm } = await import('../src/client')
- const login = schema({
+ it('hydrates matching SvelteKit page action failures without userland initialState wiring', async () => {
+ vi.stubGlobal('window', {})
+ const loginForm = schema({
email: field.string().required().email(),
+ password: field.password().required(),
})
- const form = useForm(login, {
- initialValues: {
- email: 'ava@example.com',
+ setPageForm({
+ ok: false,
+ status: 422,
+ valid: false,
+ values: {
+ email: 'bad-email',
},
- })
-
- expect(form.fields.email).toBe(form.fields.email)
- expect(form.fields.email.value).toBe('ava@example.com')
- form.fields.email.value = 'broken'
- await form.fields.email.onInput('ava@example.com')
- expect(form.values.email).toBe('ava@example.com')
- })
-
- it('exposes nested keys that are added after the wrapper is created', async () => {
- const { useForm } = await import('../src/client')
- const login = schema({
- profile: {
- city: field.string().required(),
+ errors: {
+ email: ['Enter a valid email address.'],
},
})
- const form = useForm(login, {
+ const login = useForm(loginForm, {
initialValues: {
- profile: {
- city: 'Cairo',
- },
+ email: '',
+ password: '',
},
})
- void form.values.profile
- await form.setValue('profile.country.code', 'EG')
+ await waitForActionHydration()
- expect((form.values.profile as Record).country).toEqual({
- code: 'EG',
- })
+ expect(login.values.email).toBe('bad-email')
+ expect(login.errors.first('email')).toBe('Enter a valid email address.')
})
- it('returns undefined descriptors for missing proxy keys', async () => {
- const { useForm } = await import('../src/client')
- const login = schema({
+ it('ignores action failures that belong to a different schema', async () => {
+ vi.stubGlobal('window', {})
+ const loginForm = schema({
email: field.string().required().email(),
+ password: field.password().required(),
})
- const form = useForm(login, {
- initialValues: {
- email: 'ava@example.com',
+ setPageForm({
+ ok: false,
+ status: 422,
+ valid: false,
+ values: {
+ title: '',
+ },
+ errors: {
+ title: ['Title is required.'],
},
})
- expect(Object.getOwnPropertyDescriptor(form, 'missing')).toBeUndefined()
- })
-
- it('preserves array and date values as native objects through the proxy', async () => {
- const { useForm } = await import('../src/client')
- const publishPost = schema({
- publishedAt: field.date().required(),
- tags: field.array(field.string().required()).optional(),
- })
-
- const publishedAt = new Date('2026-04-05T00:00:00.000Z')
- const form = useForm(publishPost, {
+ const login = useForm(loginForm, {
initialValues: {
- publishedAt,
- tags: ['news'],
+ email: '',
+ password: '',
},
})
- expect(form.values.publishedAt).toBeInstanceOf(Date)
- expect(form.values.publishedAt.getTime()).toBe(publishedAt.getTime())
- expect(Array.isArray(form.values.tags)).toBe(true)
- expect(form.values.tags).toEqual(['news'])
+ await waitForActionHydration()
+
+ expect(login.values.email).toBe('')
+ expect(login.errors.has('title')).toBe(false)
})
})
diff --git a/packages/adapter-sveltekit/tests/stubs/app-stores.ts b/packages/adapter-sveltekit/tests/stubs/app-stores.ts
new file mode 100644
index 00000000..4a9f3200
--- /dev/null
+++ b/packages/adapter-sveltekit/tests/stubs/app-stores.ts
@@ -0,0 +1,9 @@
+import { writable } from 'svelte/store'
+
+export const page = writable<{ readonly form: unknown }>({
+ form: null,
+})
+
+export function setPageForm(form: unknown): void {
+ page.set({ form })
+}
diff --git a/packages/adapter-sveltekit/tsup.config.ts b/packages/adapter-sveltekit/tsup.config.ts
index 9103ddf4..1e294439 100644
--- a/packages/adapter-sveltekit/tsup.config.ts
+++ b/packages/adapter-sveltekit/tsup.config.ts
@@ -13,7 +13,7 @@ export default defineConfig({
clean: true,
outDir,
outExtension: () => ({ js: '.mjs' }),
- external: ['svelte/reactivity'],
+ external: ['$app/stores', 'svelte/reactivity', 'svelte/store'],
esbuildOptions(options) {
options.logLevel = 'warning'
},
diff --git a/packages/adapter-sveltekit/vitest.config.ts b/packages/adapter-sveltekit/vitest.config.ts
index f6bc991e..07fc71fc 100644
--- a/packages/adapter-sveltekit/vitest.config.ts
+++ b/packages/adapter-sveltekit/vitest.config.ts
@@ -17,6 +17,7 @@ export default defineConfig({
'@holo-js/queue-db': resolve(__dirname, '../queue-db/src/index.ts'),
'@holo-js/session': resolve(__dirname, '../session/src/index.ts'),
'@holo-js/validation': resolve(__dirname, '../validation/src/index.ts'),
+ '$app/stores': resolve(__dirname, 'tests/stubs/app-stores.ts'),
},
},
test: {
diff --git a/packages/auth-social-discord/package.json b/packages/auth-social-discord/package.json
index 9b9bfee4..62198eb2 100644
--- a/packages/auth-social-discord/package.json
+++ b/packages/auth-social-discord/package.json
@@ -20,7 +20,7 @@
"build": "tsup",
"stub": "tsup",
"typecheck": "tsc -p tsconfig.json --noEmit",
- "test": "vitest --run --coverage"
+ "test": "vitest --run"
},
"dependencies": {
"@holo-js/auth-social": "catalog:",
diff --git a/packages/auth-social-github/package.json b/packages/auth-social-github/package.json
index 176234e4..029a25c9 100644
--- a/packages/auth-social-github/package.json
+++ b/packages/auth-social-github/package.json
@@ -23,8 +23,7 @@
"test": "vitest --run"
},
"dependencies": {
- "@holo-js/auth-social": "catalog:",
- "@holo-js/config": "catalog:"
+ "@holo-js/auth-social": "catalog:"
},
"devDependencies": {
"@types/node": "catalog:",
diff --git a/packages/auth-social-github/src/index.ts b/packages/auth-social-github/src/index.ts
index 71e58d55..3526f61b 100644
--- a/packages/auth-social-github/src/index.ts
+++ b/packages/auth-social-github/src/index.ts
@@ -7,7 +7,7 @@ import type {
} from '@holo-js/auth-social'
function applyScopes(url: URL, config: SocialRedirectContext['config']): void {
- const scopes = (config.scopes ?? []).length > 0 ? config.scopes ?? [] : ['read:user', 'user:email']
+ const scopes = config.scopes?.length ? config.scopes : ['read:user', 'user:email']
url.searchParams.set('scope', scopes.join(' '))
}
diff --git a/packages/auth-social-github/tests/package.test.ts b/packages/auth-social-github/tests/package.test.ts
index 0caa358b..3ce9fb53 100644
--- a/packages/auth-social-github/tests/package.test.ts
+++ b/packages/auth-social-github/tests/package.test.ts
@@ -2,6 +2,39 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
import githubSocialProvider from '../src'
const originalFetch = globalThis.fetch
+type GithubRedirectContext = Parameters[0]
+type GithubCallbackContext = Parameters[0]
+
+function createRedirectContext(): GithubRedirectContext {
+ return {
+ provider: 'github',
+ request: new Request('https://app.test/auth/github'),
+ state: 'state-1',
+ codeVerifier: 'verifier',
+ codeChallenge: 'challenge',
+ config: createProviderConfig(),
+ }
+}
+
+function createCallbackContext(scopes: readonly string[] = []): GithubCallbackContext {
+ return {
+ provider: 'github',
+ request: new Request('https://app.test/auth/github/callback?code=test'),
+ code: 'test-code',
+ codeVerifier: 'verifier',
+ config: createProviderConfig(scopes),
+ }
+}
+
+function createProviderConfig(scopes: readonly string[] = []) {
+ return {
+ clientId: 'client',
+ clientSecret: 'secret',
+ redirectUri: 'https://app.test/auth/github/callback',
+ scopes: [...scopes],
+ encryptTokens: false,
+ }
+}
afterEach(() => {
globalThis.fetch = originalFetch
@@ -10,20 +43,7 @@ afterEach(() => {
describe('@holo-js/auth-social-github', () => {
it('builds the authorization url with GitHub defaults', async () => {
- const url = await githubSocialProvider.buildAuthorizationUrl({
- provider: 'github',
- request: new Request('https://app.test/auth/github'),
- state: 'state-1',
- codeVerifier: 'verifier',
- codeChallenge: 'challenge',
- config: {
- clientId: 'client',
- clientSecret: 'secret',
- redirectUri: 'https://app.test/auth/github/callback',
- scopes: [],
- encryptTokens: false,
- },
- })
+ const url = await githubSocialProvider.buildAuthorizationUrl(createRedirectContext())
expect(url).toContain('github.com/login/oauth/authorize')
expect(url).toContain('scope=read%3Auser+user%3Aemail')
@@ -46,19 +66,7 @@ describe('@holo-js/auth-social-github', () => {
{ email: 'verified@example.com', verified: true, primary: false },
]), { status: 200 })) as typeof fetch
- const exchanged = await githubSocialProvider.exchangeCode({
- provider: 'github',
- request: new Request('https://app.test/auth/github/callback?code=test'),
- code: 'test-code',
- codeVerifier: 'verifier',
- config: {
- clientId: 'client',
- clientSecret: 'secret',
- redirectUri: 'https://app.test/auth/github/callback',
- scopes: [],
- encryptTokens: false,
- },
- })
+ const exchanged = await githubSocialProvider.exchangeCode(createCallbackContext())
expect(exchanged.profile).toEqual({
id: '42',
@@ -73,56 +81,20 @@ describe('@holo-js/auth-social-github', () => {
globalThis.fetch = vi.fn()
.mockResolvedValueOnce(new Response('nope', { status: 401 })) as typeof fetch
- await expect(githubSocialProvider.exchangeCode({
- provider: 'github',
- request: new Request('https://app.test/auth/github/callback?code=test'),
- code: 'test-code',
- codeVerifier: 'verifier',
- config: {
- clientId: 'client',
- clientSecret: 'secret',
- redirectUri: 'https://app.test/auth/github/callback',
- scopes: [],
- encryptTokens: false,
- },
- })).rejects.toThrow('GitHub token exchange failed')
+ await expect(githubSocialProvider.exchangeCode(createCallbackContext())).rejects.toThrow('GitHub token exchange failed')
globalThis.fetch = vi.fn()
.mockResolvedValueOnce(new Response(JSON.stringify({ access_token: 'access' }), { status: 200 }))
.mockResolvedValueOnce(new Response('nope', { status: 500 })) as typeof fetch
- await expect(githubSocialProvider.exchangeCode({
- provider: 'github',
- request: new Request('https://app.test/auth/github/callback?code=test'),
- code: 'test-code',
- codeVerifier: 'verifier',
- config: {
- clientId: 'client',
- clientSecret: 'secret',
- redirectUri: 'https://app.test/auth/github/callback',
- scopes: [],
- encryptTokens: false,
- },
- })).rejects.toThrow('GitHub user request failed')
+ await expect(githubSocialProvider.exchangeCode(createCallbackContext())).rejects.toThrow('GitHub user request failed')
globalThis.fetch = vi.fn()
.mockResolvedValueOnce(new Response(JSON.stringify({ access_token: 'access' }), { status: 200 }))
.mockResolvedValueOnce(new Response(JSON.stringify({ id: 1, login: 'octocat' }), { status: 200 }))
.mockResolvedValueOnce(new Response('nope', { status: 500 })) as typeof fetch
- await expect(githubSocialProvider.exchangeCode({
- provider: 'github',
- request: new Request('https://app.test/auth/github/callback?code=test'),
- code: 'test-code',
- codeVerifier: 'verifier',
- config: {
- clientId: 'client',
- clientSecret: 'secret',
- redirectUri: 'https://app.test/auth/github/callback',
- scopes: [],
- encryptTokens: false,
- },
- })).rejects.toThrow('GitHub email request failed')
+ await expect(githubSocialProvider.exchangeCode(createCallbackContext())).rejects.toThrow('GitHub email request failed')
})
it('fails when the GitHub profile does not include an id', async () => {
@@ -131,18 +103,6 @@ describe('@holo-js/auth-social-github', () => {
.mockResolvedValueOnce(new Response(JSON.stringify({ login: 'octocat' }), { status: 200 }))
.mockResolvedValueOnce(new Response(JSON.stringify([]), { status: 200 })) as typeof fetch
- await expect(githubSocialProvider.exchangeCode({
- provider: 'github',
- request: new Request('https://app.test/auth/github/callback?code=test'),
- code: 'test-code',
- codeVerifier: 'verifier',
- config: {
- clientId: 'client',
- clientSecret: 'secret',
- redirectUri: 'https://app.test/auth/github/callback',
- scopes: ['read:user'],
- encryptTokens: false,
- },
- })).rejects.toThrow('did not include "id"')
+ await expect(githubSocialProvider.exchangeCode(createCallbackContext(['read:user']))).rejects.toThrow('did not include "id"')
})
})
diff --git a/packages/auth/src/next-server-shim.d.ts b/packages/auth/src/next-server-shim.d.ts
index 4f8abef5..061cd554 100644
--- a/packages/auth/src/next-server-shim.d.ts
+++ b/packages/auth/src/next-server-shim.d.ts
@@ -3,6 +3,7 @@ declare module 'next/server' {
readonly path?: string
readonly secure?: boolean
readonly sameSite?: 'lax' | 'strict' | 'none'
+ readonly httpOnly?: boolean
}
type NextResponseWithCookies = Response & {
diff --git a/packages/auth/src/next/client.ts b/packages/auth/src/next/client.ts
index 97a04701..e39cb75f 100644
--- a/packages/auth/src/next/client.ts
+++ b/packages/auth/src/next/client.ts
@@ -1,5 +1,6 @@
'use client'
+import { usePathname } from 'next/navigation'
import { createContext, createElement, useCallback, useContext, useEffect, useRef, useState, type ReactNode } from 'react'
import { authClientInternals } from '../client'
import type { AuthClientRequestOptions, HoloAuthUser } from '../contracts'
@@ -33,12 +34,14 @@ function hasExplicitUseAuthOptions(options: UseAuthOptions | undefined): options
function useAuthState(
options: UseAuthOptions = {},
- stateOptions: { readonly refreshOnMount?: boolean } = {},
+ stateOptions: { readonly refreshOnMount?: boolean, readonly refreshOnRouteChange?: boolean } = {},
): UseAuthResult {
const { initialProvider, initialUser, ...requestOptions } = options
+ const pathname = usePathname()
const [currentProvider, setCurrentProvider] = useState(initialProvider ?? null)
const [currentUser, setCurrentUser] = useState(initialUser ?? null)
const requestOptionsRef = useRef(requestOptions)
+ const observedInitialPathname = useRef(false)
requestOptionsRef.current = requestOptions
@@ -62,6 +65,29 @@ function useAuthState(
}
}, [initialUser, refreshUser, stateOptions.refreshOnMount])
+ useEffect(() => {
+ if (stateOptions.refreshOnRouteChange === false) {
+ return
+ }
+
+ if (!observedInitialPathname.current) {
+ observedInitialPathname.current = true
+ return
+ }
+
+ void refreshUser()
+ }, [pathname, refreshUser, stateOptions.refreshOnRouteChange])
+
+ useEffect(() => {
+ if (typeof initialProvider !== 'undefined') {
+ setCurrentProvider(initialProvider)
+ }
+
+ if (typeof initialUser !== 'undefined') {
+ setCurrentUser(initialUser)
+ }
+ }, [initialProvider, initialUser])
+
return {
authenticated: currentUser !== null,
provider: currentProvider,
@@ -81,6 +107,7 @@ export function useAuth(options?: UseAuthOptions): UseAuthResult {
const hasOptions = hasExplicitUseAuthOptions(options)
const localAuth = useAuthState(options, {
refreshOnMount: hasOptions || !context,
+ refreshOnRouteChange: hasOptions || !context,
})
if (!hasOptions && context) {
diff --git a/packages/auth/src/next/server.ts b/packages/auth/src/next/server.ts
index c938e95b..de488fb4 100644
--- a/packages/auth/src/next/server.ts
+++ b/packages/auth/src/next/server.ts
@@ -15,6 +15,7 @@ type NextResponseCookieOptions = {
readonly path?: string
readonly secure?: boolean
readonly sameSite?: 'lax' | 'strict' | 'none'
+ readonly httpOnly?: boolean
}
type NextResponseWithCookies = Response & {
@@ -87,7 +88,7 @@ async function createCsrfCookieResponse(request: NextRouteProtectionRequest): Pr
const { NextResponse } = await import('next/server') as NextServerModule
const response = NextResponse.next()
- response.cookies.set(defaultCsrfCookieName, token, resolveCsrfCookieOptions(request.url))
+ response.cookies.set(defaultCsrfCookieName, token, resolveCsrfCookieOptions(request))
return response
}
diff --git a/packages/auth/src/runtime/csrfCookie.ts b/packages/auth/src/runtime/csrfCookie.ts
index d8dfd0b3..df738b21 100644
--- a/packages/auth/src/runtime/csrfCookie.ts
+++ b/packages/auth/src/runtime/csrfCookie.ts
@@ -4,8 +4,16 @@ export type CsrfCookieOptions = {
readonly path: '/'
readonly sameSite: 'lax'
readonly secure: boolean
+ readonly httpOnly: false
}
+type CsrfCookieRequest = {
+ readonly url: string | URL
+ readonly headers: Headers
+}
+
+type CsrfCookieTarget = string | URL | CsrfCookieRequest
+
type WebCryptoSubtle = {
importKey(
format: 'raw',
@@ -88,12 +96,49 @@ export function isCsrfCookieRequest(method: string | undefined): boolean {
return normalized === 'GET' || normalized === 'HEAD'
}
-export function resolveCsrfCookieOptions(url: string | URL): CsrfCookieOptions {
- const requestUrl = typeof url === 'string' ? new URL(url) : url
+function normalizeForwardedValue(value: string): string {
+ return value.trim().replace(/^"|"$/g, '').toLowerCase()
+}
+
+function getForwardedProto(headers: Headers): string | undefined {
+ const forwardedProto = headers.get('x-forwarded-proto')?.split(',', 1)[0]?.trim()
+ if (forwardedProto) {
+ return normalizeForwardedValue(forwardedProto)
+ }
+
+ const forwarded = headers.get('forwarded')?.split(',', 1)[0]
+ if (!forwarded) {
+ return undefined
+ }
+
+ for (const segment of forwarded.split(';')) {
+ const [name, value] = segment.split('=', 2)
+ if (name?.trim().toLowerCase() === 'proto' && value) {
+ return normalizeForwardedValue(value)
+ }
+ }
+
+ return undefined
+}
+
+function isCsrfCookieRequestTarget(target: CsrfCookieTarget): target is CsrfCookieRequest {
+ return typeof target === 'object'
+ && !(target instanceof URL)
+ && target.headers instanceof Headers
+}
+
+export function resolveCsrfCookieOptions(target: CsrfCookieTarget): CsrfCookieOptions {
+ const requestUrl = isCsrfCookieRequestTarget(target)
+ ? typeof target.url === 'string' ? new URL(target.url) : target.url
+ : typeof target === 'string' ? new URL(target) : target
+ const forwardedProto = isCsrfCookieRequestTarget(target)
+ ? getForwardedProto(target.headers)
+ : undefined
return {
path: '/',
sameSite: 'lax',
- secure: requestUrl.protocol === 'https:',
+ secure: forwardedProto === 'https' || requestUrl.protocol === 'https:',
+ httpOnly: false,
}
}
diff --git a/packages/auth/src/sveltekit/server.ts b/packages/auth/src/sveltekit/server.ts
index 13589c2f..c928add9 100644
--- a/packages/auth/src/sveltekit/server.ts
+++ b/packages/auth/src/sveltekit/server.ts
@@ -52,10 +52,7 @@ type SvelteKitStoredRequestEvent = SvelteKitHandleEvent & {
get(name: string): string | undefined
set(name: string, value: string, options: SvelteKitCookieOptions): void
}
- readonly request: {
- readonly headers: Headers
- readonly method?: string
- }
+ readonly request: Request
}
type SvelteKitResolveOptions = {
@@ -183,7 +180,17 @@ async function ensureCsrfCookie(event: SvelteKitHandleEvent): Promise {
return
}
- event.cookies.set(defaultCsrfCookieName, token, resolveCsrfCookieOptions(event.url))
+ try {
+ const { csrfInternals } = await import('@holo-js/security')
+ csrfInternals.generatedTokenCache.set(event.request, token)
+ } catch {
+ // @holo-js/security is optional for auth-only installs.
+ }
+
+ event.cookies.set(defaultCsrfCookieName, token, resolveCsrfCookieOptions({
+ url: event.url,
+ headers: event.request.headers,
+ }))
}
export async function auth(options: AuthOptions = {}): Promise {
diff --git a/packages/auth/tests/framework.test.ts b/packages/auth/tests/framework.test.ts
index a2ed1abf..58f48b50 100644
--- a/packages/auth/tests/framework.test.ts
+++ b/packages/auth/tests/framework.test.ts
@@ -86,6 +86,7 @@ describe('@holo-js/auth framework helpers', () => {
vi.resetModules()
vi.clearAllMocks()
vi.doUnmock('#imports')
+ vi.doUnmock('next/navigation')
vi.doUnmock('react')
vi.doUnmock('../src/client')
vi.doUnmock('../src/index')
@@ -96,6 +97,9 @@ describe('@holo-js/auth framework helpers', () => {
vi.doMock('../src/client', () => ({
refreshUser,
}))
+ vi.doMock('next/navigation', () => ({
+ usePathname: () => '/admin',
+ }))
vi.doMock('react', () => createReactMock())
const { AuthProvider, useAuth } = await import('../src/next/client')
@@ -116,6 +120,116 @@ describe('@holo-js/auth framework helpers', () => {
expect(refreshUser).not.toHaveBeenCalled()
})
+ it('refreshes the Next auth provider after client route changes', async () => {
+ let currentPathname = '/login'
+ let stateCursor = 0
+ let refCursor = 0
+ const states: unknown[] = []
+ const refs: { current: unknown }[] = []
+ const fetchCurrentUser = vi.fn(async () => ({
+ authenticated: true,
+ guard: 'web',
+ provider: 'users',
+ user: {
+ id: 1,
+ email: 'ava@example.com',
+ name: 'Ava',
+ },
+ }))
+
+ function resetRenderCursors() {
+ stateCursor = 0
+ refCursor = 0
+ }
+
+ vi.doMock('../src/client', () => ({
+ authClientInternals: {
+ fetchCurrentUser,
+ },
+ }))
+ vi.doMock('next/navigation', () => ({
+ usePathname: () => currentPathname,
+ }))
+ vi.doMock('react', () => ({
+ createContext(defaultValue: TValue): MockReactContext {
+ const context: MockReactContext = {
+ currentRenderValue: defaultValue,
+ Provider({ value, children }) {
+ context.currentRenderValue = value
+ return children
+ },
+ }
+
+ return context
+ },
+ createElement(type: unknown, props: Record | null, ...children: readonly unknown[]): unknown {
+ if (typeof type === 'function') {
+ return (type as (props: Record) => unknown)({
+ ...(props ?? {}),
+ children: children.length === 1 ? children[0] : children,
+ })
+ }
+
+ return { type, props, children }
+ },
+ useCallback unknown>(callback: TCallback) {
+ return callback
+ },
+ useContext(context: MockReactContext): TValue {
+ return context.currentRenderValue
+ },
+ useEffect(effect: () => void | (() => void)) {
+ return effect()
+ },
+ useRef(initialValue?: TValue) {
+ const index = refCursor
+ refCursor += 1
+ refs[index] ??= { current: initialValue }
+ return refs[index] as { current: TValue | undefined }
+ },
+ useState(initialState: TValue | (() => TValue)) {
+ const index = stateCursor
+ stateCursor += 1
+ if (!(index in states)) {
+ states[index] = typeof initialState === 'function'
+ ? (initialState as () => TValue)()
+ : initialState
+ }
+
+ return [
+ states[index] as TValue,
+ (value: TValue | ((previous: TValue) => TValue)) => {
+ states[index] = typeof value === 'function'
+ ? (value as (previous: TValue) => TValue)(states[index] as TValue)
+ : value
+ },
+ ] as const
+ },
+ }))
+
+ const { AuthProvider } = await import('../src/next/client')
+
+ resetRenderCursors()
+ AuthProvider({
+ initialProvider: null,
+ initialUser: null,
+ children: null,
+ })
+ expect(fetchCurrentUser).not.toHaveBeenCalled()
+
+ currentPathname = '/admin'
+ resetRenderCursors()
+ AuthProvider({
+ initialProvider: null,
+ initialUser: null,
+ children: null,
+ })
+
+ expect(fetchCurrentUser).toHaveBeenCalledWith({}, {
+ force: true,
+ })
+ })
+
it('does not reuse the SvelteKit auth context when explicit request options are passed', async () => {
type SvelteContextValue = unknown
@@ -379,12 +493,13 @@ describe('@holo-js/auth framework helpers', () => {
return Object.assign(response, {
cookies: {
- set(name: string, value: string, options: { readonly path?: string, readonly sameSite?: string, readonly secure?: boolean }) {
+ set(name: string, value: string, options: { readonly path?: string, readonly sameSite?: string, readonly secure?: boolean, readonly httpOnly?: boolean }) {
headers.append('set-cookie', [
`${name}=${encodeURIComponent(value)}`,
options.path ? `Path=${options.path}` : undefined,
options.sameSite ? `SameSite=${options.sameSite[0]?.toUpperCase()}${options.sameSite.slice(1)}` : undefined,
options.secure ? 'Secure' : undefined,
+ options.httpOnly ? 'HttpOnly' : undefined,
].filter((attribute): attribute is string => typeof attribute === 'string').join('; '))
},
},
@@ -399,9 +514,11 @@ describe('@holo-js/auth framework helpers', () => {
cookies: {
get: vi.fn(() => undefined),
},
- headers: new Headers(),
- nextUrl: new URL('https://app.test/login'),
- url: 'https://app.test/login',
+ headers: new Headers({
+ 'x-forwarded-proto': 'https',
+ }),
+ nextUrl: new URL('http://app.test/login'),
+ url: 'http://app.test/login',
}
const response = await protectRoutes(async () => undefined)(request)
const setCookie = response?.headers.get('set-cookie') ?? ''
@@ -416,6 +533,7 @@ describe('@holo-js/auth framework helpers', () => {
expect(setCookie).toContain('Path=/')
expect(setCookie).toContain('SameSite=Lax')
expect(setCookie).toContain('Secure')
+ expect(setCookie).not.toContain('HttpOnly')
expect(separator).toBeGreaterThan(0)
expect(signature).toBe(createHmac('sha256', 'next-csrf-signing-key')
.update(nonce)
@@ -686,14 +804,16 @@ describe('@holo-js/auth framework helpers', () => {
redirectTo: '/admin',
})({
event: {
- url: new URL('https://app.test/login'),
+ url: new URL('http://app.test/login'),
cookies: {
get: vi.fn(() => undefined),
set: setCookie,
},
request: {
method: 'GET',
- headers: new Headers(),
+ headers: new Headers({
+ 'x-forwarded-proto': 'https',
+ }),
},
},
resolve,
@@ -708,6 +828,7 @@ describe('@holo-js/auth framework helpers', () => {
path: '/',
sameSite: 'lax',
secure: true,
+ httpOnly: false,
})
expect(signature).toBe(createHmac('sha256', 'sveltekit-csrf-signing-key')
.update(nonce)
@@ -850,6 +971,7 @@ describe('@holo-js/auth framework helpers', () => {
path: '/',
sameSite: 'lax',
secure: true,
+ httpOnly: false,
})
expect(signature).toBe(createHmac('sha256', 'nuxt-csrf-signing-key')
.update(nonce)
diff --git a/packages/auth/tsup.config.ts b/packages/auth/tsup.config.ts
index 3e17ad34..ce2d0a21 100644
--- a/packages/auth/tsup.config.ts
+++ b/packages/auth/tsup.config.ts
@@ -18,7 +18,7 @@ export default defineConfig({
format: ['esm'],
dts: true,
clean: true,
- external: ['#imports', 'next/server', 'react', 'svelte', 'svelte/reactivity'],
+ external: ['#imports', 'next/navigation', 'next/server', 'react', 'svelte', 'svelte/reactivity'],
outDir,
outExtension: () => ({ js: '.mjs' }),
async onSuccess() {
diff --git a/packages/cache-db/tests/package.test.ts b/packages/cache-db/tests/package.test.ts
index 3b079c6c..f56cf012 100644
--- a/packages/cache-db/tests/package.test.ts
+++ b/packages/cache-db/tests/package.test.ts
@@ -93,18 +93,7 @@ async function createPublicFeatureHarness() {
const schema = createSchemaService(DB.connection())
await schema.sync([users])
- await schema.createTable(DEFAULT_CACHE_DATABASE_TABLE, (table) => {
- table.string('key').primaryKey()
- table.text('payload')
- table.bigInteger('expires_at').nullable()
- table.index(['expires_at'], `${DEFAULT_CACHE_DATABASE_TABLE}_expires_at_index`)
- })
- await schema.createTable(DEFAULT_CACHE_DATABASE_LOCK_TABLE, (table) => {
- table.string('name').primaryKey()
- table.string('owner')
- table.bigInteger('expires_at')
- table.index(['expires_at'], `${DEFAULT_CACHE_DATABASE_LOCK_TABLE}_expires_at_index`)
- })
+ await cacheDbInternals.prepareCacheDatabaseTables(DB.connection())
const driver = createDatabaseCacheDriver({
name: 'database',
@@ -198,77 +187,6 @@ describe('@holo-js/cache-db', () => {
connectionName: 'cache',
driver: 'postgres',
})
- expect(cacheDbInternals.createDatabaseContextOptions('cache', {
- driver: 'postgres',
- url: 'postgres://cache.internal/db',
- port: '5432' as never,
- })).toMatchObject({
- connectionName: 'cache',
- driver: 'postgres',
- })
- const stringPortOptions = cacheDbInternals.createDatabaseContextOptions('cache', {
- driver: 'postgres',
- host: 'cache.internal',
- database: 'app',
- username: 'user',
- password: 'secret',
- port: '5433' as never,
- })
- const adapter = stringPortOptions.adapter as {
- readonly options?: {
- readonly config?: {
- readonly host?: string
- readonly port?: number
- readonly user?: string
- readonly password?: string
- readonly database?: string
- }
- }
- }
-
- expect(adapter.options?.config).toMatchObject({
- host: 'cache.internal',
- port: 5433,
- user: 'user',
- password: 'secret',
- database: 'app',
- })
-
- const invalidStringPortOptions = cacheDbInternals.createDatabaseContextOptions('cache', {
- driver: 'postgres',
- host: 'cache.internal',
- database: 'app',
- username: 'user',
- password: 'secret',
- port: 'not-a-port' as never,
- })
- const invalidStringAdapter = invalidStringPortOptions.adapter as {
- readonly options?: {
- readonly config?: {
- readonly port?: number
- }
- }
- }
-
- expect(invalidStringAdapter.options?.config?.port).toBeUndefined()
-
- const partiallyNumericPortOptions = cacheDbInternals.createDatabaseContextOptions('cache', {
- driver: 'postgres',
- host: 'cache.internal',
- database: 'app',
- username: 'user',
- password: 'secret',
- port: '5433abc' as never,
- })
- const partiallyNumericAdapter = partiallyNumericPortOptions.adapter as {
- readonly options?: {
- readonly config?: {
- readonly port?: number
- }
- }
- }
-
- expect(partiallyNumericAdapter.options?.config?.port).toBeUndefined()
})
it('creates cache tables through the shared schema helper', async () => {
diff --git a/packages/cache-redis/package.json b/packages/cache-redis/package.json
index ba858c97..92ce7f34 100644
--- a/packages/cache-redis/package.json
+++ b/packages/cache-redis/package.json
@@ -21,7 +21,7 @@
"stub": "tsup",
"typecheck": "tsc -p tsconfig.json --noEmit",
"test": "vitest --run",
- "test:integration": "HOLO_REDIS_INTEGRATION=1 vitest --run tests/real-redis.test.ts"
+ "test:integration": "HOLO_REDIS_INTEGRATION=1 vitest --run"
},
"peerDependencies": {
"@holo-js/cache": "catalog:"
diff --git a/packages/cache-redis/tests/package.test.ts b/packages/cache-redis/tests/package.test.ts
index 76b2ce0a..394f26c1 100644
--- a/packages/cache-redis/tests/package.test.ts
+++ b/packages/cache-redis/tests/package.test.ts
@@ -1,225 +1,72 @@
import { beforeEach, describe, expect, it, vi } from 'vitest'
const redisMock = vi.hoisted(() => {
- const state = new Map()
- const lockOwners = new Map()
- const calls = {
- constructorArgs: [] as unknown[][],
- del: [] as string[][],
- disconnect: [] as true[],
- eval: [] as Array<[string, number, ...string[]]>,
- get: [] as string[],
- incrby: [] as Array<[string, number]>,
- scan: [] as Array<[string, string, string, string, number]>,
- set: [] as Array<[string, string, ...(string | number)[]]>,
- }
-
- function resolveExpiresAt(arguments_: readonly (string | number)[], now: number): number | undefined {
- const pxAtIndex = arguments_.findIndex(argument_ => argument_ === 'PXAT')
- if (pxAtIndex >= 0) {
- const expiresAt = arguments_[pxAtIndex + 1]
- return typeof expiresAt === 'number' ? expiresAt : undefined
- }
-
- const pxIndex = arguments_.findIndex(argument_ => argument_ === 'PX')
- if (pxIndex >= 0) {
- const ttlMilliseconds = arguments_[pxIndex + 1]
- return typeof ttlMilliseconds === 'number' ? now + ttlMilliseconds : undefined
- }
-
- return undefined
- }
-
- function hasNx(arguments_: readonly (string | number)[]): boolean {
- return arguments_.includes('NX')
- }
-
- function isExpired(key: string, now: number): boolean {
- const entry = state.get(key)
- if (!entry || typeof entry.expiresAt === 'undefined' || entry.expiresAt > now) {
- return false
- }
-
- state.delete(key)
- return true
- }
-
- class FakeRedis {
- static Cluster = class FakeRedisCluster {
- readonly isCluster = true
-
- constructor(...args: unknown[]) {
- calls.constructorArgs.push(args)
- }
-
- async get(key: string): Promise {
- return new FakeRedis().get(key)
- }
-
- async set(key: string, value: string, ...arguments_: readonly (string | number)[]): Promise<'OK' | null> {
- return new FakeRedis().set(key, value, ...arguments_)
- }
-
- async del(...keys: string[]): Promise {
- return new FakeRedis().del(...keys)
- }
-
- async scan(
- cursor: string,
- matchLabel: string,
- pattern: string,
- countLabel: string,
- count: number,
- ): Promise<[string, string[]]> {
- return new FakeRedis().scan(cursor, matchLabel, pattern, countLabel, count)
- }
-
- async incrby(key: string, amount: number): Promise {
- return new FakeRedis().incrby(key, amount)
- }
-
- async decrby(key: string, amount: number): Promise {
- return new FakeRedis().decrby(key, amount)
- }
-
- async eval(script: string, numberOfKeys: number, ...arguments_: readonly string[]): Promise {
- return new FakeRedis().eval(script, numberOfKeys, ...arguments_)
- }
-
- disconnect(): void {
- calls.disconnect.push(true)
- }
-
- nodes(): readonly FakeRedis[] {
- return [new FakeRedis(), new FakeRedis()]
- }
- }
-
- constructor(...args: unknown[]) {
- calls.constructorArgs.push(args)
- }
-
- disconnect(): void {
- calls.disconnect.push(true)
- }
-
- async get(key: string): Promise {
- calls.get.push(key)
- if (isExpired(key, Date.now())) {
- return null
- }
-
- return state.get(key)?.value ?? null
- }
-
- async set(key: string, value: string, ...arguments_: readonly (string | number)[]): Promise<'OK' | null> {
- calls.set.push([key, value, ...arguments_])
- if (isExpired(key, Date.now())) {
- state.delete(key)
- }
-
- if (hasNx(arguments_) && state.has(key)) {
- return null
- }
-
- state.set(key, {
- value,
- expiresAt: resolveExpiresAt(arguments_, Date.now()),
- })
- if (key.includes(':lock:')) {
- lockOwners.set(key, value)
- }
-
- return 'OK'
- }
-
- async del(...keys: string[]): Promise {
- calls.del.push(keys)
- let deleted = 0
- for (const key of keys) {
- if (state.delete(key)) {
- deleted += 1
- lockOwners.delete(key)
- }
- }
-
- return deleted
- }
-
- async scan(
+ class MockRedisClient {
+ readonly get = vi.fn<(key: string) => Promise>(async () => null)
+ readonly set = vi.fn<(key: string, value: string, ...arguments_: readonly (string | number)[]) => Promise<'OK' | null>>(async () => 'OK')
+ readonly del = vi.fn<(...keys: string[]) => Promise>(async () => 0)
+ readonly scan = vi.fn<(
cursor: string,
matchLabel: string,
pattern: string,
countLabel: string,
count: number,
- ): Promise<[string, string[]]> {
- calls.scan.push([cursor, matchLabel, pattern, countLabel, count])
- const regex = new RegExp(`^${pattern.replace(/\\\*/g, '\\*').replace(/\*/g, '.*')}$`)
- const keys = [...state.keys()].filter(key => regex.test(key))
- return ['0', keys]
- }
+ ) => Promise<[string, string[]]>>(async () => ['0', []])
+ readonly incrby = vi.fn<(key: string, amount: number) => Promise>(async () => 0)
+ readonly decrby = vi.fn<(key: string, amount: number) => Promise>(async () => 0)
+ readonly eval = vi.fn<(script: string, numberOfKeys: number, ...arguments_: readonly string[]) => Promise>(async () => 0)
+ readonly disconnect = vi.fn<() => void>()
+ nodes?: ReturnType readonly MockRedisClient[]>>
+ }
- async incrby(key: string, amount: number): Promise {
- calls.incrby.push([key, amount])
- if (key.includes('timeout')) {
- throw new Error('ETIMEDOUT')
- }
+ const constructorArgs: unknown[][] = []
+ const standaloneClients: MockRedisClient[] = []
+ const clusterClients: MockRedisClient[] = []
+ let clusterNodes: readonly MockRedisClient[] = []
+ let exposeClusterNodes = true
- if (key.includes('wrongtype')) {
- throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value')
- }
+ class FakeRedis extends MockRedisClient {
+ static Cluster = class FakeRedisCluster extends MockRedisClient {
+ readonly isCluster = true
- const current = await this.get(key)
- const currentNumber = current === null ? 0 : Number(current)
- if (!Number.isInteger(currentNumber)) {
- throw new Error('ERR value is not an integer or out of range')
+ constructor(...args: unknown[]) {
+ super()
+ constructorArgs.push(args)
+ clusterClients.push(this)
+ if (exposeClusterNodes) {
+ this.nodes = vi.fn<(role: 'master') => readonly MockRedisClient[]>(() => clusterNodes)
+ }
}
-
- const nextValue = currentNumber + amount
- state.set(key, {
- value: String(nextValue),
- expiresAt: state.get(key)?.expiresAt,
- })
- return nextValue
- }
-
- async decrby(key: string, amount: number): Promise {
- return this.incrby(key, -amount)
}
- async eval(script: string, numberOfKeys: number, ...arguments_: readonly string[]): Promise {
- calls.eval.push([script, numberOfKeys, ...arguments_])
- const [key, owner] = arguments_
- if (typeof key !== 'string' || typeof owner !== 'string') {
- return 0
- }
-
- if (lockOwners.get(key) !== owner) {
- return 0
- }
-
- lockOwners.delete(key)
- return state.delete(key) ? 1 : 0
+ constructor(...args: unknown[]) {
+ super()
+ constructorArgs.push(args)
+ standaloneClients.push(this)
}
}
return {
- calls,
FakeRedis,
- lockOwners,
+ clusterClients,
+ constructorArgs,
+ createClient() {
+ return new MockRedisClient()
+ },
+ disableClusterNodes() {
+ exposeClusterNodes = false
+ },
reset() {
- state.clear()
- lockOwners.clear()
- calls.constructorArgs.length = 0
- calls.del.length = 0
- calls.disconnect.length = 0
- calls.eval.length = 0
- calls.get.length = 0
- calls.incrby.length = 0
- calls.scan.length = 0
- calls.set.length = 0
+ constructorArgs.length = 0
+ standaloneClients.length = 0
+ clusterClients.length = 0
+ clusterNodes = []
+ exposeClusterNodes = true
+ },
+ setClusterNodes(nodes: readonly MockRedisClient[]) {
+ clusterNodes = nodes
},
- state,
+ standaloneClients,
}
})
@@ -232,13 +79,59 @@ import { createRedisCacheDriver, redisCacheDriverInternals } from '../src/index'
const cacheDriverDisposeSymbol = Symbol.for('holo.cache.driver.dispose')
+type RedisLockClient = Parameters[0]
+
+function lastStandaloneClient(): (typeof redisMock.standaloneClients)[number] {
+ const client = redisMock.standaloneClients.at(-1)
+ if (!client) {
+ throw new Error('Expected a standalone Redis client to be created.')
+ }
+
+ return client
+}
+
+function lastClusterClient(): (typeof redisMock.clusterClients)[number] {
+ const client = redisMock.clusterClients.at(-1)
+ if (!client) {
+ throw new Error('Expected a Redis cluster client to be created.')
+ }
+
+ return client
+}
+
+function createLockClient(): RedisLockClient {
+ return {
+ async get() {
+ return null
+ },
+ async set() {
+ return 'OK'
+ },
+ async del() {
+ return 0
+ },
+ async scan() {
+ return ['0', []]
+ },
+ async incrby() {
+ return 0
+ },
+ async decrby() {
+ return 0
+ },
+ async eval() {
+ return 0
+ },
+ }
+}
+
describe('@holo-js/cache-redis', () => {
beforeEach(() => {
redisMock.reset()
vi.useRealTimers()
})
- it('reads, writes, adds, forgets, and flushes within the configured prefix scope', async () => {
+ it('maps cache operations to the configured redis prefix scope', async () => {
const driver = createRedisCacheDriver({
name: 'redis',
connectionName: 'cache',
@@ -249,6 +142,19 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
})
+ const client = lastStandaloneClient()
+
+ client.get.mockResolvedValueOnce('"one"')
+ client.set
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce(null)
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce('OK')
+ client.del
+ .mockResolvedValueOnce(1)
+ .mockResolvedValueOnce(0)
+ .mockResolvedValueOnce(1)
+ client.scan.mockResolvedValueOnce(['0', ['holo:cache:alpha']])
expect(await driver.put({
key: 'holo:cache:alpha',
@@ -278,14 +184,14 @@ describe('@holo-js/cache-redis', () => {
})
await driver.flush()
- expect(await driver.get('holo:cache:alpha')).toEqual({ hit: false })
- expect(await driver.get('other:gamma')).toEqual({
- hit: true,
- payload: '"outside"',
- })
- expect(redisMock.calls.scan).toEqual([
- ['0', 'MATCH', 'holo:cache:*', 'COUNT', 100],
+ expect(client.set.mock.calls).toEqual([
+ ['holo:cache:alpha', '"one"', 'PXAT', expect.any(Number)],
+ ['holo:cache:alpha', '"two"', 'PXAT', expect.any(Number), 'NX'],
+ ['holo:cache:beta', '"two"', 'PXAT', expect.any(Number), 'NX'],
+ ['other:gamma', '"outside"'],
])
+ expect(client.scan).toHaveBeenCalledWith('0', 'MATCH', 'holo:cache:*', 'COUNT', 100)
+ expect(client.del).toHaveBeenLastCalledWith('holo:cache:alpha')
})
it('disconnects its redis client through the runtime lifecycle hook', () => {
@@ -299,6 +205,7 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
}) as ReturnType & Record void>
+ const client = lastStandaloneClient()
const dispose = driver[cacheDriverDisposeSymbol]
if (!dispose) {
@@ -307,10 +214,10 @@ describe('@holo-js/cache-redis', () => {
dispose()
- expect(redisMock.calls.disconnect).toEqual([true])
+ expect(client.disconnect).toHaveBeenCalledOnce()
})
- it('supports expiration and immediate-expiry writes', async () => {
+ it('passes expiration options to redis and deletes immediate-expiry writes', async () => {
vi.useFakeTimers()
vi.setSystemTime(new Date('2026-04-22T00:00:00.000Z'))
@@ -324,48 +231,40 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
})
+ const client = lastStandaloneClient()
+
+ client.set
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce(null)
+ .mockResolvedValueOnce('OK')
await driver.put({
key: 'holo:cache:ttl',
payload: '"ok"',
expiresAt: Date.now() + 1_000,
})
- expect(await driver.get('holo:cache:ttl')).toEqual({
- hit: true,
- payload: '"ok"',
- })
-
- vi.advanceTimersByTime(1_001)
- expect(await driver.get('holo:cache:ttl')).toEqual({ hit: false })
-
await driver.put({
key: 'holo:cache:expired',
payload: '"gone"',
expiresAt: Date.now() - 1,
})
- expect(await driver.get('holo:cache:expired')).toEqual({ hit: false })
-
+ expect(await driver.add({
+ key: 'holo:cache:live-add',
+ payload: '"expired-replacement"',
+ expiresAt: Date.now() - 1,
+ })).toBe(false)
expect(await driver.add({
key: 'holo:cache:stale-add',
payload: '"gone"',
expiresAt: Date.now() - 1,
})).toBe(true)
- expect(await driver.get('holo:cache:stale-add')).toEqual({ hit: false })
- await driver.put({
- key: 'holo:cache:live-add',
- payload: '"original"',
- expiresAt: Date.now() + 60_000,
- })
- expect(await driver.add({
- key: 'holo:cache:live-add',
- payload: '"expired-replacement"',
- expiresAt: Date.now() - 1,
- })).toBe(false)
- expect(await driver.get('holo:cache:live-add')).toEqual({
- hit: true,
- payload: '"original"',
- })
+ expect(client.set.mock.calls).toEqual([
+ ['holo:cache:ttl', '"ok"', 'PXAT', Date.now() + 1_000],
+ ['holo:cache:live-add', '"expired-replacement"', 'PXAT', Date.now() - 1, 'NX'],
+ ['holo:cache:stale-add', '"gone"', 'PXAT', Date.now() - 1, 'NX'],
+ ])
+ expect(client.del).toHaveBeenCalledWith('holo:cache:expired')
})
it('supports numeric mutation and rejects non-numeric values', async () => {
@@ -379,86 +278,134 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
})
+ const client = lastStandaloneClient()
+
+ client.incrby
+ .mockResolvedValueOnce(2)
+ .mockRejectedValueOnce(new Error('ERR value is not an integer or out of range'))
+ client.decrby
+ .mockResolvedValueOnce(1)
+ .mockRejectedValueOnce(new Error('WRONGTYPE Operation against a key holding the wrong kind of value'))
expect(await driver.increment('holo:cache:counter', 2)).toBe(2)
expect(await driver.decrement('holo:cache:counter', 1)).toBe(1)
- await driver.put({
- key: 'holo:cache:label',
- payload: '"text"',
- })
await expect(driver.increment('holo:cache:label', 1)).rejects.toThrow(CacheInvalidNumericMutationError)
await expect(driver.decrement('holo:cache:label', 1)).rejects.toThrow(CacheInvalidNumericMutationError)
})
- it('implements redis-backed locks with owner-safe release and blocking', async () => {
- vi.useFakeTimers()
- vi.setSystemTime(new Date('2026-04-22T00:00:00.000Z'))
-
- const driver = createRedisCacheDriver({
- name: 'redis',
- connectionName: 'cache',
- prefix: 'holo:cache:',
- redis: {
- host: '127.0.0.1',
- port: 6379,
- db: 0,
- },
- sleep: async (milliseconds) => {
- vi.advanceTimersByTime(milliseconds)
- },
- ownerFactory: (() => {
- let counter = 0
- return () => `owner-${++counter}`
- })(),
- })
-
- const firstLock = driver.lock('holo:cache:lock:report', 1)
- const secondLock = driver.lock('holo:cache:lock:report', 1)
+ it('implements redis-backed locks with owner-safe release', async () => {
+ const client = createLockClient()
+ const set = vi.spyOn(client, 'set')
+ const evaluate = vi.spyOn(client, 'eval')
+ let counter = 0
+
+ set
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce(null)
+ .mockResolvedValueOnce('OK')
+ evaluate
+ .mockResolvedValueOnce(0)
+ .mockResolvedValueOnce(1)
+ .mockResolvedValueOnce(1)
+
+ const firstLock = redisCacheDriverInternals.createRedisLock(
+ client,
+ 'holo:cache:lock:report',
+ 1,
+ () => `owner-${++counter}`,
+ async () => {},
+ Date.now,
+ )
+ const secondLock = redisCacheDriverInternals.createRedisLock(
+ client,
+ 'holo:cache:lock:report',
+ 1,
+ () => `owner-${++counter}`,
+ async () => {},
+ Date.now,
+ )
expect(await firstLock.get()).toBe(true)
expect(await secondLock.get()).toBe(false)
expect(await secondLock.release()).toBe(false)
expect(await firstLock.release()).toBe(true)
expect(await secondLock.get(async () => 'after-release')).toBe('after-release')
+ expect(evaluate).toHaveBeenCalledTimes(3)
+ })
- const blockingLock = driver.lock('holo:cache:lock:wait', 0.02)
- expect(await blockingLock.get()).toBe(true)
+ it('uses injected sleep and clocks for blocking lock deadlines', async () => {
+ let currentTime = 0
+ const client = createLockClient()
+ const set = vi.spyOn(client, 'set')
+ const sleepCalls: number[] = []
- const waited = driver.lock('holo:cache:lock:wait', 0.02).block(0.05, async () => 'after-wait')
- await expect(waited).resolves.toBe('after-wait')
+ set
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce(null)
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce(null)
+ .mockResolvedValueOnce(null)
- const heldLock = driver.lock('holo:cache:lock:timeout', 1)
+ const heldLock = redisCacheDriverInternals.createRedisLock(
+ client,
+ 'holo:cache:lock:wait',
+ 0.02,
+ () => 'owner-1',
+ async (milliseconds) => {
+ sleepCalls.push(milliseconds)
+ currentTime += milliseconds
+ },
+ () => currentTime,
+ )
expect(await heldLock.get()).toBe(true)
- await expect(driver.lock('holo:cache:lock:timeout', 1).block(0)).resolves.toBe(false)
- })
- it('uses the injected clock for blocking lock deadlines', async () => {
- let currentTime = 0
- const driver = createRedisCacheDriver({
- name: 'redis',
- connectionName: 'cache',
- prefix: 'holo:cache:',
- redis: {
- host: '127.0.0.1',
- port: 6379,
- db: 0,
+ const waitedLock = redisCacheDriverInternals.createRedisLock(
+ client,
+ 'holo:cache:lock:wait',
+ 0.02,
+ () => 'owner-2',
+ async (milliseconds) => {
+ sleepCalls.push(milliseconds)
+ currentTime += milliseconds
+ },
+ () => currentTime,
+ )
+ await expect(waitedLock.block(0.05, async () => 'after-wait')).resolves.toBe('after-wait')
+
+ const clockLock = redisCacheDriverInternals.createRedisLock(
+ client,
+ 'holo:cache:lock:clock',
+ 1,
+ () => 'owner-3',
+ async (milliseconds) => {
+ sleepCalls.push(milliseconds)
+ currentTime += milliseconds
},
- now: () => currentTime,
- sleep: async (milliseconds) => {
+ () => currentTime,
+ )
+ expect(await clockLock.get()).toBe(true)
+ await expect(redisCacheDriverInternals.createRedisLock(
+ client,
+ 'holo:cache:lock:clock',
+ 1,
+ () => 'owner-4',
+ async (milliseconds) => {
+ sleepCalls.push(milliseconds)
currentTime += milliseconds
},
- })
+ () => currentTime,
+ ).block(0.02)).resolves.toBe(false)
- expect(await driver.lock('holo:cache:lock:clock', 1).get()).toBe(true)
- await expect(driver.lock('holo:cache:lock:clock', 1).block(0.02)).resolves.toBe(false)
+ expect(sleepCalls).toEqual([10, 10, 10])
})
it('does not retry blocking lock acquisition after the wait deadline', async () => {
let currentTime = 0
let setCalls = 0
const sleepCalls: number[] = []
- const client: Parameters[0] = {
+ const client: RedisLockClient = {
async get() {
return null
},
@@ -502,6 +449,14 @@ describe('@holo-js/cache-redis', () => {
})
it('flushes every cluster master when using a redis cluster client', async () => {
+ const firstNode = redisMock.createClient()
+ const secondNode = redisMock.createClient()
+ redisMock.setClusterNodes([firstNode, secondNode])
+ firstNode.scan.mockResolvedValueOnce(['0', ['holo:cache:alpha']])
+ secondNode.scan.mockResolvedValueOnce(['0', ['holo:cache:beta']])
+ firstNode.del.mockResolvedValueOnce(1)
+ secondNode.del.mockResolvedValueOnce(1)
+
const driver = createRedisCacheDriver({
name: 'redis-cluster',
connectionName: 'cache',
@@ -513,49 +468,34 @@ describe('@holo-js/cache-redis', () => {
],
},
})
+ const clusterClient = lastClusterClient()
- await driver.put({
- key: 'holo:cache:alpha',
- payload: '"one"',
- })
- await driver.put({
- key: 'holo:cache:beta',
- payload: '"two"',
- })
await driver.flush()
- expect(redisMock.calls.scan).toEqual([
- ['0', 'MATCH', 'holo:cache:*', 'COUNT', 100],
- ['0', 'MATCH', 'holo:cache:*', 'COUNT', 100],
- ])
- expect(redisMock.calls.del.every(keys => keys.length === 1)).toBe(true)
+ expect(clusterClient.nodes).toHaveBeenCalledWith('master')
+ expect(firstNode.scan).toHaveBeenCalledWith('0', 'MATCH', 'holo:cache:*', 'COUNT', 100)
+ expect(secondNode.scan).toHaveBeenCalledWith('0', 'MATCH', 'holo:cache:*', 'COUNT', 100)
+ expect(firstNode.del).toHaveBeenCalledWith('holo:cache:alpha')
+ expect(secondNode.del).toHaveBeenCalledWith('holo:cache:beta')
})
it('handles cluster clients that do not expose master node iteration', async () => {
- const clusterPrototype = redisMock.FakeRedis.Cluster.prototype as {
- nodes?: (role: 'master') => readonly unknown[]
- }
- const originalNodes = clusterPrototype.nodes
- clusterPrototype.nodes = undefined
-
- try {
- const driver = createRedisCacheDriver({
- name: 'redis-cluster',
- connectionName: 'cache',
- prefix: 'holo:cache:',
- redis: {
- db: 0,
- clusters: [
- { host: 'cache-a.internal', port: 6379 },
- ],
- },
- })
+ redisMock.disableClusterNodes()
+ const driver = createRedisCacheDriver({
+ name: 'redis-cluster',
+ connectionName: 'cache',
+ prefix: 'holo:cache:',
+ redis: {
+ db: 0,
+ clusters: [
+ { host: 'cache-a.internal', port: 6379 },
+ ],
+ },
+ })
+ const clusterClient = lastClusterClient()
- await expect(driver.flush()).resolves.toBeUndefined()
- expect(redisMock.calls.scan).toEqual([])
- } finally {
- clusterPrototype.nodes = originalNodes
- }
+ await expect(driver.flush()).resolves.toBeUndefined()
+ expect(clusterClient.nodes).toBeUndefined()
})
it('prefers url, then clusters, then host/socket when creating redis clients', async () => {
@@ -592,7 +532,7 @@ describe('@holo-js/cache-redis', () => {
},
})
- expect(redisMock.calls.constructorArgs).toEqual([
+ expect(redisMock.constructorArgs).toEqual([
[
'redis://cache.internal:6380/2',
{
@@ -641,6 +581,7 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
})
+ lastStandaloneClient().set.mockResolvedValueOnce('OK')
expect(await hostDriver.add({
key: 'holo:cache:forever-add',
payload: '"ok"',
@@ -680,6 +621,12 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
})
+ const client = lastStandaloneClient()
+
+ client.incrby
+ .mockRejectedValueOnce(new Error('WRONGTYPE boom'))
+ .mockRejectedValueOnce(new Error('ETIMEDOUT'))
+ client.decrby.mockRejectedValueOnce(new Error('ETIMEDOUT'))
await expect(driver.increment('holo:cache:wrongtype', 1)).rejects.toThrow(CacheInvalidNumericMutationError)
await expect(driver.increment('holo:cache:timeout', 1)).rejects.toThrow('ETIMEDOUT')
@@ -781,6 +728,11 @@ describe('@holo-js/cache-redis', () => {
db: 0,
},
})
+ const client = lastStandaloneClient()
+
+ client.set
+ .mockResolvedValueOnce('OK')
+ .mockResolvedValueOnce(null)
const heldLock = driver.lock('holo:cache:lock:default-sleep', 1)
expect(await heldLock.get()).toBe(true)
diff --git a/packages/cache-redis/vitest.config.ts b/packages/cache-redis/vitest.config.ts
index af288ede..378a2897 100644
--- a/packages/cache-redis/vitest.config.ts
+++ b/packages/cache-redis/vitest.config.ts
@@ -16,7 +16,7 @@ export default defineConfig({
name: '@holo-js/cache-redis',
environment: 'node',
include: runRedisIntegration
- ? ['tests/**/*.test.ts']
+ ? ['tests/real-redis.test.ts']
: ['tests/package.test.ts'],
coverage: {
provider: 'v8',
diff --git a/packages/cli/package.json b/packages/cli/package.json
index d3b2315a..2ddfc727 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -23,7 +23,7 @@
"build": "node ../../scripts/generate-cli-workspace-catalog.mjs && tsup",
"stub": "node ../../scripts/generate-cli-workspace-catalog.mjs && tsup --watch",
"typecheck": "tsc -p tsconfig.json --noEmit",
- "test": "vitest --run && bun run test:integration",
+ "test": "vitest --run && HOLO_CLI_INCLUDE_INTEGRATION=1 vitest --run tests/cli.test.ts",
"test:integration": "HOLO_CLI_INCLUDE_INTEGRATION=1 vitest --run tests/cli.test.ts"
},
"dependencies": {
diff --git a/packages/cli/tests/vitest-config.test.ts b/packages/cli/tests/vitest-config.test.ts
index 7b905097..f7085683 100644
--- a/packages/cli/tests/vitest-config.test.ts
+++ b/packages/cli/tests/vitest-config.test.ts
@@ -40,7 +40,8 @@ describe('@holo-js/cli vitest config', () => {
})
it('runs CLI integration tests from the package test script', () => {
- expect(packageJson.scripts.test).toContain('test:integration')
+ expect(packageJson.scripts.test).toContain('HOLO_CLI_INCLUDE_INTEGRATION=1')
+ expect(packageJson.scripts.test).toContain('tests/cli.test.ts')
expect(packageJson.scripts['test:integration']).toContain('HOLO_CLI_INCLUDE_INTEGRATION=1')
expect(packageJson.scripts['test:integration']).toContain('tests/cli.test.ts')
})
diff --git a/packages/config/src/access.ts b/packages/config/src/access.ts
index 51425bc6..1d4a36f5 100644
--- a/packages/config/src/access.ts
+++ b/packages/config/src/access.ts
@@ -82,11 +82,11 @@ export function useConfig>(
export function useConfig>(path: TPath): ValueAtPath
export function useConfig(path: string): unknown
export function useConfig(path: string): unknown {
- return createConfigAccessors(requireConfigRuntime()).useConfig(path)
+ return getValueAtPath(requireConfigRuntime() as Record, path)
}
export function config>(path: TPath): ValueAtPath
export function config(path: string): unknown
export function config(path: string): unknown {
- return createConfigAccessors(requireConfigRuntime()).config(path)
+ return getValueAtPath(requireConfigRuntime() as Record, path)
}
diff --git a/packages/config/src/loader.ts b/packages/config/src/loader.ts
index 61199bed..019d6994 100644
--- a/packages/config/src/loader.ts
+++ b/packages/config/src/loader.ts
@@ -273,25 +273,7 @@ function normalizeLoadedConfig(
const auth = normalizeAuthConfig(resolvedRawConfig.auth as HoloAuthConfig | undefined, {
appKey: app.key,
})
-
- const customEntries = Object.entries(resolvedRawConfig).filter(([key]) => {
- return key !== 'app'
- && key !== 'database'
- && key !== 'redis'
- && key !== 'cache'
- && key !== 'cors'
- && key !== 'storage'
- && key !== 'queue'
- && key !== 'broadcast'
- && key !== 'mail'
- && key !== 'notifications'
- && key !== 'media'
- && key !== 'session'
- && key !== 'security'
- && key !== 'auth'
- })
- const custom = Object.freeze(Object.fromEntries(customEntries)) as Readonly
- const all = Object.freeze({
+ const firstPartyConfig = {
app,
database,
redis,
@@ -306,24 +288,19 @@ function normalizeLoadedConfig(
session,
security,
auth,
+ }
+ const firstPartyConfigKeys = new Set(Object.keys(firstPartyConfig))
+ const customEntries = Object.entries(resolvedRawConfig).filter(([key]) => {
+ return !firstPartyConfigKeys.has(key)
+ })
+ const custom = Object.freeze(Object.fromEntries(customEntries)) as Readonly
+ const all = Object.freeze({
+ ...firstPartyConfig,
...custom,
}) as Readonly['all']>
return {
- app,
- database,
- redis,
- cache,
- cors,
- storage,
- queue,
- broadcast,
- mail,
- notifications,
- media,
- session,
- security,
- auth,
+ ...firstPartyConfig,
custom,
all,
environment: options.environment,
diff --git a/packages/config/tests/broadcast-config.type.test.ts b/packages/config/tests/broadcast-config.type.test.ts
index 637f1080..b267377b 100644
--- a/packages/config/tests/broadcast-config.type.test.ts
+++ b/packages/config/tests/broadcast-config.type.test.ts
@@ -1,9 +1,9 @@
import { describe, it } from 'vitest'
import {
- createConfigAccessors,
defineBroadcastConfig,
type HoloConfigRegistry,
} from '../src'
+import { createConfigAccessorFixture } from './support/configAccessors'
describe('@holo-js/config broadcast typing', () => {
it('preserves broadcast inference through config helpers and dot-path access', () => {
@@ -27,21 +27,8 @@ describe('@holo-js/config broadcast typing', () => {
},
})
- const accessors = createConfigAccessors({
- app: {} as HoloConfigRegistry['app'],
- database: {} as HoloConfigRegistry['database'],
- redis: {} as HoloConfigRegistry['redis'],
- cache: {} as HoloConfigRegistry['cache'],
- cors: {} as HoloConfigRegistry['cors'],
- storage: {} as HoloConfigRegistry['storage'],
- queue: {} as HoloConfigRegistry['queue'],
+ const accessors = createConfigAccessorFixture({
broadcast: broadcast as unknown as HoloConfigRegistry['broadcast'],
- mail: {} as HoloConfigRegistry['mail'],
- notifications: {} as HoloConfigRegistry['notifications'],
- media: {} as HoloConfigRegistry['media'],
- session: {} as HoloConfigRegistry['session'],
- security: {} as HoloConfigRegistry['security'],
- auth: {} as HoloConfigRegistry['auth'],
services: {
mailgun: {
secret: 'secret',
diff --git a/packages/config/tests/config.type.test.ts b/packages/config/tests/config.type.test.ts
index 4b98d09f..6c581ec9 100644
--- a/packages/config/tests/config.type.test.ts
+++ b/packages/config/tests/config.type.test.ts
@@ -1,6 +1,5 @@
import { describe, it } from 'vitest'
import {
- createConfigAccessors,
defineAuthConfig,
defineBroadcastConfig,
defineCacheConfig,
@@ -15,6 +14,7 @@ import {
type HoloAppEnv,
type HoloConfigRegistry,
} from '../src'
+import { createConfigAccessorFixture } from './support/configAccessors'
declare module '../src/types' {
interface HoloConfigRegistry {
@@ -148,18 +148,12 @@ describe('@holo-js/config typing', () => {
},
},
})
- const accessors = createConfigAccessors({
- app: {} as HoloConfigRegistry['app'],
- database: {} as HoloConfigRegistry['database'],
- redis: {} as HoloConfigRegistry['redis'],
+ const accessors = createConfigAccessorFixture({
cache: cache as unknown as HoloConfigRegistry['cache'],
- cors: {} as HoloConfigRegistry['cors'],
- storage: {} as HoloConfigRegistry['storage'],
queue: queue as unknown as HoloConfigRegistry['queue'],
broadcast: broadcast as unknown as HoloConfigRegistry['broadcast'],
mail: mail as unknown as HoloConfigRegistry['mail'],
notifications: notifications as unknown as HoloConfigRegistry['notifications'],
- media: {} as HoloConfigRegistry['media'],
session: session as unknown as HoloConfigRegistry['session'],
security: security as unknown as HoloConfigRegistry['security'],
auth: auth as unknown as HoloConfigRegistry['auth'],
diff --git a/packages/config/tests/security-config.type.test.ts b/packages/config/tests/security-config.type.test.ts
index 0acfaa9d..9aa89f0f 100644
--- a/packages/config/tests/security-config.type.test.ts
+++ b/packages/config/tests/security-config.type.test.ts
@@ -1,10 +1,10 @@
import { describe, it } from 'vitest'
import {
- createConfigAccessors,
defineCorsConfig,
defineSecurityConfig,
type HoloConfigRegistry,
} from '../src'
+import { createConfigAccessorFixture } from './support/configAccessors'
describe('@holo-js/config security typing', () => {
it('preserves security inference through config helpers and dot-path access', () => {
@@ -34,21 +34,9 @@ describe('@holo-js/config security typing', () => {
statefulDomains: ['app.example.com'],
})
- const accessors = createConfigAccessors({
- app: {} as HoloConfigRegistry['app'],
- database: {} as HoloConfigRegistry['database'],
- redis: {} as HoloConfigRegistry['redis'],
- cache: {} as HoloConfigRegistry['cache'],
+ const accessors = createConfigAccessorFixture({
cors: cors as unknown as HoloConfigRegistry['cors'],
- storage: {} as HoloConfigRegistry['storage'],
- queue: {} as HoloConfigRegistry['queue'],
- broadcast: {} as HoloConfigRegistry['broadcast'],
- mail: {} as HoloConfigRegistry['mail'],
- notifications: {} as HoloConfigRegistry['notifications'],
- media: {} as HoloConfigRegistry['media'],
- session: {} as HoloConfigRegistry['session'],
security: security as unknown as HoloConfigRegistry['security'],
- auth: {} as HoloConfigRegistry['auth'],
services: {
mailgun: {
secret: 'secret',
diff --git a/packages/config/tests/support/configAccessors.ts b/packages/config/tests/support/configAccessors.ts
new file mode 100644
index 00000000..985f32ea
--- /dev/null
+++ b/packages/config/tests/support/configAccessors.ts
@@ -0,0 +1,42 @@
+import {
+ createConfigAccessors,
+ type HoloConfigMap,
+ type HoloConfigRegistry,
+} from '../../src'
+
+type ServicesFixtureConfig = {
+ readonly mailgun: {
+ readonly secret: string
+ }
+}
+
+const defaultConfigRegistry = {
+ app: {} as HoloConfigRegistry['app'],
+ database: {} as HoloConfigRegistry['database'],
+ redis: {} as HoloConfigRegistry['redis'],
+ cache: {} as HoloConfigRegistry['cache'],
+ cors: {} as HoloConfigRegistry['cors'],
+ storage: {} as HoloConfigRegistry['storage'],
+ queue: {} as HoloConfigRegistry['queue'],
+ broadcast: {} as HoloConfigRegistry['broadcast'],
+ mail: {} as HoloConfigRegistry['mail'],
+ notifications: {} as HoloConfigRegistry['notifications'],
+ media: {} as HoloConfigRegistry['media'],
+ session: {} as HoloConfigRegistry['session'],
+ security: {} as HoloConfigRegistry['security'],
+ auth: {} as HoloConfigRegistry['auth'],
+ services: {
+ mailgun: {
+ secret: 'secret',
+ },
+ },
+} satisfies HoloConfigRegistry & { readonly services: ServicesFixtureConfig }
+
+export function createConfigAccessorFixture(
+ overrides: TOverrides,
+) {
+ return createConfigAccessors({
+ ...defaultConfigRegistry,
+ ...overrides,
+ })
+}
diff --git a/packages/core/src/portable/holo.ts b/packages/core/src/portable/holo.ts
index 8b8fe5bf..ea5e64a8 100644
--- a/packages/core/src/portable/holo.ts
+++ b/packages/core/src/portable/holo.ts
@@ -1,9 +1,7 @@
import { AsyncLocalStorage } from 'node:async_hooks'
import { existsSync } from 'node:fs'
import { createHash, createHmac } from 'node:crypto'
-import { createRequire } from 'node:module'
import { resolve } from 'node:path'
-import { pathToFileURL } from 'node:url'
import {
config as globalConfig,
configureConfigRuntime,
@@ -23,7 +21,7 @@ import {
Entity,
resetDB,
} from '@holo-js/db'
-import { importBundledRuntimeModule } from '../runtimeModule'
+import { importBundledRuntimeModule, importOptionalRuntimeModule } from '../runtimeModule'
import { resolveRuntimeConnectionManagerOptions } from './dbRuntime'
import { loadGeneratedProjectRegistry, type GeneratedProjectRegistry } from './registry'
import { configurePlainNodeStorageRuntime, resetOptionalStorageRuntime } from '../storageRuntime'
@@ -1071,54 +1069,13 @@ function restoreOptionalSubsystemRuntimeBindings(
const BROADCAST_PUBLISH_TIMEOUT_MS = 10_000
-const portableRuntimeRequire = createRequire(import.meta.url)
-
-function resolveOptionalImportSpecifier(specifier: string, projectRoot?: string): string {
- if (!projectRoot) {
- return specifier
- }
-
- try {
- const resolved = portableRuntimeRequire.resolve(specifier, {
- paths: [projectRoot],
- })
- return pathToFileURL(resolved).href
- } catch {
- return specifier
- }
-}
-
async function importOptionalModule(
specifier: string,
options: {
readonly projectRoot?: string
} = {},
): Promise {
- const resolvedSpecifier = resolveOptionalImportSpecifier(specifier, options.projectRoot)
-
- try {
- return await import(/* webpackIgnore: true */ resolvedSpecifier as string) as TModule
- } catch (error) {
- /* v8 ignore start -- optional-package absence is validated in published-package integration, not in this monorepo test graph */
- if (
- error instanceof Error
- && (
- error.message.includes(`Cannot find package '${specifier}'`)
- || error.message.includes(`Cannot find module '${specifier}'`)
- || error.message.includes(`Failed to load url ${specifier}`)
- || error.message.includes(`Could not resolve "${specifier}"`)
- || error.message.includes(`Cannot find package '${resolvedSpecifier}'`)
- || error.message.includes(`Cannot find module '${resolvedSpecifier}'`)
- || error.message.includes(`Failed to load url ${resolvedSpecifier}`)
- || error.message.includes(`Could not resolve "${resolvedSpecifier}"`)
- )
- ) {
- return undefined
- }
- /* v8 ignore stop */
-
- throw error
- }
+ return importOptionalRuntimeModule(specifier, options)
}
const portableRuntimeModuleInternals = {
diff --git a/packages/core/src/runtimeModule.ts b/packages/core/src/runtimeModule.ts
index 9a3e15cc..e582ac18 100644
--- a/packages/core/src/runtimeModule.ts
+++ b/packages/core/src/runtimeModule.ts
@@ -1,6 +1,7 @@
import { mkdtemp, mkdir, rm, stat, writeFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
import { basename, extname, join } from 'node:path'
-import { pathToFileURL } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
import type { BuildOptions, BuildResult } from 'esbuild'
type EsbuildModule = {
@@ -15,6 +16,96 @@ async function importModule(specifier: string): Promise {
return import(/* webpackIgnore: true */ specifier) as Promise
}
+const runtimeModuleRequire = createRequire(import.meta.url)
+
+function resolveOptionalImportSpecifier(specifier: string, projectRoot?: string): string {
+ if (!projectRoot) {
+ return specifier
+ }
+
+ try {
+ return pathToFileURL(runtimeModuleRequire.resolve(specifier, {
+ paths: [projectRoot],
+ })).href
+ } catch {
+ return specifier
+ }
+}
+
+function getErrorMessage(error: unknown): string {
+ return error && typeof error === 'object' && 'message' in error
+ && typeof (error as { message?: unknown }).message === 'string'
+ ? (error as { message: string }).message
+ : ''
+}
+
+function getMissingModuleTarget(message: string): string | undefined {
+ const match = message.match(/Cannot find package '([^']+)'|Cannot find module '([^']+)'|Failed to load url ([^ ]+)|Could not resolve "([^"]+)"/)
+ return match?.slice(1).find((value): value is string => typeof value === 'string')
+}
+
+function normalizeImportSpecifier(specifier: string): string {
+ return specifier.startsWith('file://') ? fileURLToPath(specifier) : specifier
+}
+
+function normalizeImportTarget(value: string): string {
+ return normalizeImportSpecifier(value).replace(/\\/g, '/')
+}
+
+function matchesRelativeImportTarget(failedTarget: string | undefined, specifier: string): boolean {
+ if (!failedTarget || !specifier.startsWith('.')) {
+ return false
+ }
+
+ const suffix = specifier.startsWith('./') ? specifier.slice(2) : specifier
+ return normalizeImportTarget(failedTarget).endsWith(`/${suffix}`)
+}
+
+function isMissingOptionalModule(error: unknown, specifier: string, resolvedSpecifier: string): boolean {
+ if (!error || typeof error !== 'object') {
+ return false
+ }
+
+ const message = getErrorMessage(error)
+ const failedTarget = getMissingModuleTarget(message)
+ const expectedTargets = new Set([
+ specifier,
+ resolvedSpecifier,
+ normalizeImportTarget(specifier),
+ normalizeImportTarget(resolvedSpecifier),
+ ])
+ const normalizedFailedTarget = typeof failedTarget === 'string' ? normalizeImportTarget(failedTarget) : undefined
+ const matchesRequestedTarget = typeof normalizedFailedTarget === 'string'
+ && (expectedTargets.has(normalizedFailedTarget) || matchesRelativeImportTarget(normalizedFailedTarget, specifier))
+
+ return (
+ ('code' in error && (error as { code?: unknown }).code === 'ERR_MODULE_NOT_FOUND' && matchesRequestedTarget)
+ || (message.startsWith('Cannot find package \'') && matchesRequestedTarget)
+ || (message.startsWith('Cannot find module \'') && matchesRequestedTarget)
+ || (message.includes('Does the file exist?') && message.startsWith('Failed to load url ') && matchesRequestedTarget)
+ || (message.startsWith('Could not resolve "') && matchesRequestedTarget)
+ )
+}
+
+export async function importOptionalRuntimeModule(
+ specifier: string,
+ options: {
+ readonly projectRoot?: string
+ } = {},
+): Promise {
+ const resolvedSpecifier = resolveOptionalImportSpecifier(specifier, options.projectRoot)
+
+ try {
+ return await importModule(resolvedSpecifier)
+ } catch (error) {
+ if (isMissingOptionalModule(error, specifier, resolvedSpecifier)) {
+ return undefined
+ }
+
+ throw error
+ }
+}
+
async function pathExists(path: string): Promise {
try {
await stat(path)
@@ -144,6 +235,7 @@ async function runEsbuild(options: BuildOptions): Promise {
export const runtimeModuleInternals = {
bundleRuntimeModule,
importModule,
+ importOptionalRuntimeModule,
loadEsbuild,
pathExists,
runEsbuild,
diff --git a/packages/core/src/storageRuntime.ts b/packages/core/src/storageRuntime.ts
index 3f18b1d6..6978b8d2 100644
--- a/packages/core/src/storageRuntime.ts
+++ b/packages/core/src/storageRuntime.ts
@@ -1,7 +1,7 @@
import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
import { dirname, isAbsolute, join, relative, resolve, sep, win32 } from 'node:path'
-import { fileURLToPath } from 'node:url'
import type { LoadedHoloConfig, HoloConfigMap } from '@holo-js/config'
+import { importOptionalRuntimeModule } from './runtimeModule'
type StorageBackend = {
getItem(key: string): Promise
@@ -67,42 +67,7 @@ type StorageS3Module = {
}
async function importOptionalModule(specifier: string): Promise {
- try {
- if (process.env.VITEST) {
- return await import(/* @vite-ignore */ specifier) as TModule
- }
-
- return await import(/* webpackIgnore: true */ specifier) as TModule
- } catch (error) {
- const message = error && typeof error === 'object' && 'message' in error
- && typeof (error as { message?: unknown }).message === 'string'
- ? (error as { message: string }).message
- : ''
- const resolvedSpecifier = specifier.startsWith('file://')
- ? fileURLToPath(specifier)
- : specifier
- const failedTarget = message.match(/Cannot find package '([^']+)'|Cannot find module '([^']+)'|Failed to load url ([^ ]+)/)?.slice(1)
- .find((value): value is string => typeof value === 'string')
- const matchesRequestedTarget = failedTarget === specifier || failedTarget === resolvedSpecifier
- const isMissingOptionalModule = error && typeof error === 'object'
- && (
- ('code' in error && (error as { code?: unknown }).code === 'ERR_MODULE_NOT_FOUND')
- /* v8 ignore start -- these fallback string variants depend on the host loader's exact missing-module wording */
- // Node reports missing ESM packages as "Cannot find package ''".
- || (message.startsWith('Cannot find package \'') && matchesRequestedTarget)
- // Node reports missing CJS/URL imports as "Cannot find module ''".
- || (message.startsWith('Cannot find module \'') && matchesRequestedTarget)
- /* v8 ignore stop */
- // Vite reports unresolved optional imports as "Failed to load url ... Does the file exist?".
- || (message.includes('Does the file exist?') && message.startsWith('Failed to load url ') && matchesRequestedTarget)
- )
-
- if (isMissingOptionalModule) {
- return undefined
- }
-
- throw error
- }
+ return importOptionalRuntimeModule(specifier)
}
export function resolveStorageKeyPath(root: string, key: string): string {
diff --git a/packages/core/tests/dbRuntime.test.ts b/packages/core/tests/dbRuntime.test.ts
index 545c9a56..3a72632f 100644
--- a/packages/core/tests/dbRuntime.test.ts
+++ b/packages/core/tests/dbRuntime.test.ts
@@ -1,489 +1,13 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
- createAdapter,
- createDialect,
- createRuntimeConnectionOptions,
- createRuntimeLogger,
- isSupportedDatabaseDriver,
- parseDatabaseDriver,
- resolveRuntimeConnectionManagerOptions,
-} from '../src/portable/dbRuntime'
-
-type AdapterHarness = {
- config?: Record
-}
+import { describe, expect, it } from 'vitest'
+import * as dbRuntime from '@holo-js/db'
+import * as core from '../src'
+import * as portable from '../src/portable/dbRuntime'
describe('core db runtime bootstrap', () => {
- it('does not create a logger or log security override when db logging is disabled', () => {
- const options = createRuntimeConnectionOptions('sqlite', './data.sqlite', false)
-
- expect(options.logger).toBeUndefined()
- expect(options.security).toBeUndefined()
- })
-
- it('creates a logger and enables visible SQL/bindings when db logging is enabled', () => {
- const options = createRuntimeConnectionOptions('sqlite', './data.sqlite', true)
-
- expect(options.logger).toBeDefined()
- expect(options.security).toEqual({
- debugSqlInLogs: true,
- redactBindingsInLogs: false,
- })
- })
-
- it('propagates an optional schema name into runtime connection options', () => {
- const options = createRuntimeConnectionOptions('mysql', 'mysql://db', false, 'analytics')
-
- expect(options.schemaName).toBe('analytics')
- })
-
- it('creates Postgres runtime adapters from structured credentials when no URL is provided', () => {
- const options = createRuntimeConnectionOptions('postgres', {
- host: 'db.internal',
- port: 5432,
- username: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- }, false, 'public', 'primary')
-
- const adapter = options.adapter as unknown as AdapterHarness
-
- expect(adapter.config).toMatchObject({
- host: 'db.internal',
- port: 5432,
- user: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- })
- })
-
- it('resolves documented multi-connection runtime config shapes', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- defaultConnection: 'analytics',
- connections: {
- primary: {
- driver: 'sqlite',
- database: './storage/app.sqlite',
- },
- analytics: {
- driver: 'postgres',
- url: 'postgresql://analytics',
- schema: 'warehouse',
- logging: true,
- },
- },
- },
- })
-
- expect(options.getDefaultConnectionName()).toBe('analytics')
- expect(options.getConnectionNames()).toEqual(['primary', 'analytics'])
- expect(options.connection('primary').getDriver()).toBe('sqlite')
- expect(options.connection('primary').getSchemaName()).toBeUndefined()
- expect(options.connection('analytics').getDriver()).toBe('postgres')
- expect(options.connection('analytics').getSchemaName()).toBe('warehouse')
- expect(options.connection('analytics').getLogger()).toBeDefined()
- })
-
- it('uses the sole named connection as default when no explicit default is configured', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- analytics: {
- driver: 'postgres',
- url: 'postgresql://analytics',
- },
- },
- },
- })
-
- expect(options.getDefaultConnectionName()).toBe('analytics')
- expect(options.getConnectionNames()).toEqual(['analytics'])
- })
-
- it('resolves structured credential fields for named network connections', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- defaultConnection: 'primary',
- connections: {
- primary: {
- driver: 'postgres',
- host: 'db.internal',
- port: 5432,
- username: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- },
- analytics: {
- driver: 'mysql',
- host: 'mysql.internal',
- port: '3306',
- username: 'reporter',
- password: 'top-secret',
- database: 'analytics',
- schema: 'warehouse',
- },
- },
- },
- })
-
- const primaryAdapter = options.connection('primary').getAdapter() as unknown as AdapterHarness
- const analyticsAdapter = options.connection('analytics').getAdapter() as unknown as AdapterHarness
-
- expect(options.connection('primary').getDriver()).toBe('postgres')
- expect(primaryAdapter.config).toMatchObject({
- host: 'db.internal',
- port: 5432,
- user: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- })
- expect(options.connection('analytics').getDriver()).toBe('mysql')
- expect(options.connection('analytics').getSchemaName()).toBe('warehouse')
- expect(analyticsAdapter.config).toMatchObject({
- host: 'mysql.internal',
- port: 3306,
- user: 'reporter',
- password: 'top-secret',
- database: 'analytics',
- })
- })
-
- it('falls back to sqlite defaults when no connection map exists', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- holo: {},
- })
-
- expect(options.getDefaultConnectionName()).toBe('default')
- expect(options.getConnectionNames()).toEqual(['default'])
- expect(options.connection().getDriver()).toBe('sqlite')
- expect(options.connection().getSchemaName()).toBeUndefined()
- expect(options.connection().getLogger()).toBeUndefined()
- })
-
- it('supports canonical structured credential fields without a URL', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- default: {
- driver: 'postgres',
- host: 'db.internal',
- port: '5432',
- username: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- schema: 'public',
- },
- },
- },
- })
-
- const adapter = options.connection().getAdapter() as unknown as AdapterHarness
-
- expect(options.connection().getDriver()).toBe('postgres')
- expect(options.connection().getSchemaName()).toBe('public')
- expect(adapter.config).toMatchObject({
- host: 'db.internal',
- port: 5432,
- user: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- })
- })
-
- it('requires an explicit driver when using host-style connection fields', () => {
- expect(() => resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- primary: {
- host: 'db.internal',
- username: 'app',
- password: 'secret',
- database: 'primary',
- },
- },
- },
- })).toThrow('must declare a database driver when using host, port, username, password, or ssl settings')
- })
-
- it('marks Postgres and MySQL runtime dialects as alter-capable', () => {
- expect(createDialect('sqlite').capabilities.ddlAlterSupport).toBe(false)
- expect(createDialect('postgres').capabilities.ddlAlterSupport).toBe(true)
- expect(createDialect('mysql').capabilities.ddlAlterSupport).toBe(true)
- })
-
- it('logs query and transaction lifecycle events when enabled', () => {
- const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
- const error = vi.spyOn(console, 'error').mockImplementation(() => {})
-
- const logger = createRuntimeLogger(true)
-
- expect(logger).toBeDefined()
-
- logger?.onQuerySuccess?.({
- kind: 'query',
- connectionName: 'default',
- sql: 'select * from "users"',
- bindings: ['ops@example.com'],
- scope: 'root',
- durationMs: 12,
- rowCount: 2,
- })
-
- logger?.onQueryError?.({
- kind: 'execute',
- connectionName: 'default',
- sql: 'delete from "users"',
- bindings: [],
- scope: 'transaction',
- durationMs: 7,
- error: new Error('boom'),
- })
-
- logger?.onTransactionStart?.({
- scope: 'transaction',
- depth: 1,
- })
-
- logger?.onTransactionCommit?.({
- scope: 'savepoint',
- depth: 2,
- savepointName: 'sp_1',
- })
-
- logger?.onTransactionRollback?.({
- scope: 'savepoint',
- depth: 2,
- savepointName: 'sp_2',
- error: new Error('rollback'),
- })
-
- expect(warn).toHaveBeenCalledTimes(4)
- expect(error).toHaveBeenCalledTimes(1)
- expect(warn.mock.calls[0]?.[0]).toContain('[holo:db] query ok connection=default')
- expect(warn.mock.calls[0]?.[0]).toContain('sql=select * from "users"')
- expect(error.mock.calls[0]?.[0]).toContain('[holo:db] execute error connection=default')
- expect(warn.mock.calls[3]?.[0]).toContain('transaction rollback')
-
- warn.mockRestore()
- error.mockRestore()
- })
-
- it('returns no runtime logger when disabled', () => {
- expect(createRuntimeLogger(false)).toBeUndefined()
- })
-
- it('covers driver parsing helpers and adapter factories', () => {
- expect(isSupportedDatabaseDriver('sqlite')).toBe(true)
- expect(isSupportedDatabaseDriver('mongo')).toBe(false)
- expect(parseDatabaseDriver(undefined, 'mysql')).toBe('mysql')
- expect(parseDatabaseDriver('postgres', 'sqlite')).toBe('postgres')
- expect(() => parseDatabaseDriver('mongo', 'sqlite')).toThrow('Unsupported Holo database driver')
-
- expect(createAdapter('postgres', 'postgresql://db.internal/app')).toBeDefined()
- expect(createAdapter('postgres', {
- host: 'db.internal',
- port: 5432,
- username: 'app',
- password: 'secret',
- database: 'primary',
- ssl: { rejectUnauthorized: false },
- })).toBeDefined()
-
- expect(createAdapter('mysql', 'mysql://db.internal/app')).toBeDefined()
- expect(createAdapter('mysql', {
- host: 'db.internal',
- port: 3306,
- username: 'app',
- password: 'secret',
- database: 'primary',
- })).toBeDefined()
-
- expect(createAdapter('sqlite', { database: './data/app.sqlite' })).toBeDefined()
- expect(() => createAdapter('mongo' as never, 'mongodb://db')).toThrow('Unsupported Holo database driver')
- expect(createDialect('sqlite').createPlaceholder(3)).toBe('?')
- })
-
- it('covers remaining runtime logger branches', () => {
- const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
- const logger = createRuntimeLogger(true)
-
- logger?.onQuerySuccess?.({
- kind: 'query',
- connectionName: 'analytics',
- sql: 'update "users" set "name" = ?',
- bindings: [],
- scope: 'root',
- durationMs: 4,
- affectedRows: 3,
- })
-
- logger?.onTransactionStart?.({
- scope: 'transaction',
- depth: 1,
- savepointName: 'sp_1',
- })
-
- logger?.onTransactionCommit?.({
- scope: 'transaction',
- depth: 1,
- })
-
- logger?.onTransactionRollback?.({
- scope: 'transaction',
- depth: 1,
- error: 'forced rollback',
- })
-
- logger?.onQuerySuccess?.({
- kind: 'query',
- connectionName: 'analytics',
- sql: 'select 1',
- bindings: [],
- scope: 'root',
- durationMs: 1,
- })
-
- expect(warn.mock.calls[0]?.[0]).toContain('affected=3')
- expect(warn.mock.calls[1]?.[0]).toContain('savepoint=sp_1')
- expect(warn.mock.calls[2]?.[0]).toContain('transaction commit')
- expect(warn.mock.calls[3]?.[0]).toContain('error=forced rollback')
- expect(warn.mock.calls[4]?.[0]).toContain('duration=1ms sql=select 1')
-
- warn.mockRestore()
- })
-
- it('falls back to sqlite defaults when no runtime config is provided', () => {
- const options = resolveRuntimeConnectionManagerOptions({})
-
- expect(options.getDefaultConnectionName()).toBe('default')
- expect(options.connection().getDriver()).toBe('sqlite')
- })
-
- it('normalizes undefined connection entries as empty configs', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- default: undefined as never,
- },
- },
- })
-
- expect(options.getDefaultConnectionName()).toBe('default')
- expect(options.connection().getDriver()).toBe('sqlite')
- })
-
- it('supports sqlite filename and invalid port fallbacks in named connections', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- defaultConnection: 'local',
- connections: {
- local: {
- filename: './data/local.sqlite',
- port: 'not-a-port',
- logging: true,
- },
- },
- },
- })
-
- expect(options.getDefaultConnectionName()).toBe('local')
- expect(options.connection('local').getDriver()).toBe('sqlite')
- expect(options.connection('local').getLogger()).toBeDefined()
- })
-
- it('infers drivers from string connection inputs and default connection names', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- default: 'mysql://default.internal/app',
- analytics: 'postgresql://analytics.internal/app',
- },
- },
- })
-
- expect(options.getDefaultConnectionName()).toBe('default')
- expect(options.connection('default').getDriver()).toBe('mysql')
- expect(options.connection('analytics').getDriver()).toBe('postgres')
- })
-
- it('infers sqlite drivers from filesystem-style urls', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- absolute: '/tmp/app.db',
- filedb: 'file:./data/app.sqlite',
- memory: ':memory:',
- relative: '../data/app.sqlite3',
- sqlite: './data/app.sqlite',
- },
- },
- })
-
- expect(options.connection('absolute').getDriver()).toBe('sqlite')
- expect(options.connection('filedb').getDriver()).toBe('sqlite')
- expect(options.connection('memory').getDriver()).toBe('sqlite')
- expect(options.connection('relative').getDriver()).toBe('sqlite')
- expect(options.connection('sqlite').getDriver()).toBe('sqlite')
- })
-
- it('falls back to the default runtime driver when a url does not imply one', () => {
- const options = resolveRuntimeConnectionManagerOptions({
- db: {
- connections: {
- unknown: 'https://example.test/not-a-db-url',
- },
- },
- })
-
- expect(options.connection('unknown').getDriver()).toBe('sqlite')
- })
-
- it('covers adapter fallbacks and logger string branches', () => {
- expect(createAdapter('mysql', {
- host: 'db.internal',
- port: 3306,
- username: 'app',
- password: 'secret',
- database: 'primary',
- ssl: true,
- })).toBeDefined()
- expect(createAdapter('sqlite', {})).toBeDefined()
- expect(createDialect('postgres').quoteIdentifier('users.email')).toBe('"users"."email"')
- expect(createDialect('postgres').createPlaceholder(2)).toBe('$2')
- expect(createDialect('mysql').quoteIdentifier('users.email')).toBe('`users`.`email`')
- expect(createDialect('mysql').createPlaceholder(9)).toBe('?')
- expect(createDialect('sqlite').quoteIdentifier('users')).toBe('"users"')
-
- const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
- const error = vi.spyOn(console, 'error').mockImplementation(() => {})
- const logger = createRuntimeLogger(true)
-
- logger?.onQueryError?.({
- kind: 'query',
- connectionName: 'default',
- sql: 'select 1',
- bindings: [],
- scope: 'root',
- durationMs: 1,
- error: 'boom',
- })
-
- logger?.onTransactionRollback?.({
- scope: 'transaction',
- depth: 1,
- })
-
- expect(error.mock.calls[0]?.[0]).toContain('error=boom')
- expect(warn.mock.calls[0]?.[0]).toContain('transaction rollback scope=transaction depth=1')
-
- warn.mockRestore()
- error.mockRestore()
+ it('preserves the core db runtime re-export contract', () => {
+ expect(portable.createRuntimeConnectionOptions).toBe(dbRuntime.createRuntimeConnectionOptions)
+ expect(portable.resolveRuntimeConnectionManagerOptions).toBe(dbRuntime.resolveRuntimeConnectionManagerOptions)
+ expect(core.createRuntimeConnectionOptions).toBe(dbRuntime.createRuntimeConnectionOptions)
+ expect(core.resolveRuntimeConnectionManagerOptions).toBe(dbRuntime.resolveRuntimeConnectionManagerOptions)
})
})
diff --git a/packages/core/tests/runtime.test.ts b/packages/core/tests/runtime.test.ts
index 082db50c..bbd883af 100644
--- a/packages/core/tests/runtime.test.ts
+++ b/packages/core/tests/runtime.test.ts
@@ -18,7 +18,8 @@ import {
notify,
resetNotificationsRuntime,
} from '@holo-js/notifications'
-import { configureMailRuntime, listFakeSentMails, mailRuntimeInternals, previewMail, resetFakeSentMails } from '@holo-js/mail'
+import { configureMailRuntime, listFakeSentMails, previewMail, resetFakeSentMails } from '@holo-js/mail'
+import { mailRuntimeInternals } from '../../mail/src/runtime'
import {
Event,
defineEvent,
diff --git a/packages/core/tests/runtimeModule.test.ts b/packages/core/tests/runtimeModule.test.ts
index 26461765..a9b83b8e 100644
--- a/packages/core/tests/runtimeModule.test.ts
+++ b/packages/core/tests/runtimeModule.test.ts
@@ -91,6 +91,22 @@ describe('@holo-js/core runtime module helpers', () => {
}
})
+ it('does not hide missing transitive dependencies in optional runtime modules', async () => {
+ const projectRoot = await createTempProject()
+ const missingPath = join(projectRoot, 'missing.mjs')
+ const entryPath = join(projectRoot, 'optional.mjs')
+
+ await expect(
+ runtimeModuleInternals.importOptionalRuntimeModule(pathToFileURL(missingPath).href),
+ ).resolves.toBeUndefined()
+
+ await writeFile(entryPath, 'import "./missing-child.mjs"\nexport const loaded = true\n', 'utf8')
+
+ await expect(
+ runtimeModuleInternals.importOptionalRuntimeModule(pathToFileURL(entryPath).href),
+ ).rejects.toThrow()
+ })
+
it('returns the default esbuild export when the imported module does not expose build directly', async () => {
await expect(runtimeModuleInternals.loadEsbuild()).resolves.toEqual(expect.objectContaining({
build: expect.any(Function),
diff --git a/packages/core/tests/storageRuntime.test.ts b/packages/core/tests/storageRuntime.test.ts
index 93f9d300..345c9668 100644
--- a/packages/core/tests/storageRuntime.test.ts
+++ b/packages/core/tests/storageRuntime.test.ts
@@ -54,19 +54,17 @@ describe('@holo-js/core storage runtime optional imports', () => {
await expect(resetOptionalStorageRuntime()).rejects.toBe('boom')
})
- it('imports optional storage modules through the webpackIgnore branch outside Vitest', async () => {
+ it('imports optional storage modules through the shared optional runtime loader', async () => {
const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-'))
tempDirs.push(root)
const modulePath = join(root, 'module.mjs')
await writeFile(modulePath, 'export default "loaded"\n', 'utf8')
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(pathToFileURL(modulePath).href)).resolves.toEqual(
- expect.objectContaining({
- default: 'loaded',
- }),
- )
- })
+ await expect(storageRuntimeInternals.importOptionalModule(pathToFileURL(modulePath).href)).resolves.toEqual(
+ expect.objectContaining({
+ default: 'loaded',
+ }),
+ )
})
it('treats missing optional storage modules as optional inside Vitest as well', async () => {
@@ -90,36 +88,6 @@ describe('@holo-js/core storage runtime optional imports', () => {
})
})
- it('rethrows module evaluation failures with a non-matching error code outside Vitest', async () => {
- const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-code-boom-'))
- tempDirs.push(root)
- const modulePath = join(root, 'code-boom.mjs')
- await writeFile(modulePath, 'throw Object.assign(new Error("boom"), { code: "E_CUSTOM" })\n', 'utf8')
-
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(pathToFileURL(modulePath).href)).rejects.toThrow('boom')
- })
- })
-
- it('rethrows module evaluation failures without an Error object outside Vitest', async () => {
- const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-string-boom-'))
- tempDirs.push(root)
- const modulePath = join(root, 'string-boom.mjs')
- await writeFile(modulePath, 'throw "boom"\n', 'utf8')
-
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(pathToFileURL(modulePath).href)).rejects.toBe('boom')
- })
- })
-
- it('treats module resolution failures with a resolver message as optional outside Vitest', async () => {
- const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-resolve-'))
- tempDirs.push(root)
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(pathToFileURL(join(root, 'missing.mjs')).href)).resolves.toBeUndefined()
- })
- })
-
it('does not treat unrelated "Failed to load url" failures as missing modules', async () => {
const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-failed-url-'))
tempDirs.push(root)
@@ -130,18 +98,6 @@ describe('@holo-js/core storage runtime optional imports', () => {
})
})
- it('treats matching Vite missing-url messages as optional outside Vitest', async () => {
- const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-vite-missing-'))
- tempDirs.push(root)
- const modulePath = join(root, 'vite-missing.mjs')
- const moduleUrl = pathToFileURL(modulePath).href
- await writeFile(modulePath, `throw new Error(${JSON.stringify(`Failed to load url ${moduleUrl} Does the file exist?`)})\n`, 'utf8')
-
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(moduleUrl)).resolves.toBeUndefined()
- })
- })
-
it('returns undefined for missing optional storage modules outside Vitest', async () => {
const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-missing-'))
tempDirs.push(root)
@@ -150,23 +106,4 @@ describe('@holo-js/core storage runtime optional imports', () => {
})
})
- it('treats matching "Cannot find module" loader messages as optional outside Vitest', async () => {
- const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-cannot-find-'))
- tempDirs.push(root)
- const modulePath = join(root, 'cannot-find.mjs')
- const moduleUrl = pathToFileURL(modulePath).href
- await writeFile(modulePath, `throw new Error(${JSON.stringify(`Cannot find module '${moduleUrl}'`)})\n`, 'utf8')
-
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(moduleUrl)).resolves.toBeUndefined()
- })
- })
-
- it('treats missing absolute-path optional storage modules as optional outside Vitest', async () => {
- const root = await mkdtemp(join(tmpdir(), 'holo-storage-runtime-absolute-missing-'))
- tempDirs.push(root)
- await withoutVitestEnv(async () => {
- await expect(storageRuntimeInternals.importOptionalModule(join(root, 'missing.mjs'))).resolves.toBeUndefined()
- })
- })
})
diff --git a/packages/db-mysql/package.json b/packages/db-mysql/package.json
index 7606f1e3..0d803f55 100644
--- a/packages/db-mysql/package.json
+++ b/packages/db-mysql/package.json
@@ -20,7 +20,8 @@
"build": "tsup",
"stub": "tsup --watch",
"typecheck": "tsc -p tsconfig.json --noEmit",
- "test": "vitest --run"
+ "test": "vitest --run",
+ "test:integration": "HOLO_MYSQL_INTEGRATION=1 vitest --run tests/mysql.test.ts"
},
"peerDependencies": {
"@holo-js/db": "catalog:"
diff --git a/packages/db-mysql/src/index.ts b/packages/db-mysql/src/index.ts
index 49126f44..ace9684d 100644
--- a/packages/db-mysql/src/index.ts
+++ b/packages/db-mysql/src/index.ts
@@ -6,37 +6,9 @@ import mysql, {
type ResultSetHeader,
type RowDataPacket,
} from 'mysql2/promise'
+import type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '@holo-js/db'
-export interface DriverQueryResult = Record> {
- rows: TRow[]
- rowCount: number
-}
-
-export interface DriverExecutionResult {
- affectedRows?: number
- lastInsertId?: number | string
-}
-
-export interface DriverAdapter {
- initialize(): Promise
- disconnect(): Promise
- isConnected(): boolean
- runWithTransactionScope?(callback: () => Promise): Promise
- query = Record>(
- sql: string,
- bindings?: readonly unknown[],
- ): Promise>
- execute(
- sql: string,
- bindings?: readonly unknown[],
- ): Promise
- beginTransaction(): Promise
- commit(): Promise
- rollback(): Promise
- createSavepoint?(name: string): Promise
- rollbackToSavepoint?(name: string): Promise
- releaseSavepoint?(name: string): Promise
-}
+export type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '@holo-js/db'
class TransactionError extends Error {}
@@ -65,7 +37,6 @@ export interface MySQLAdapterOptions {
type ScopedMySQLTransaction = {
client: MySQLClientLike
leased: boolean
- released: boolean
}
type RawMySQLClientLike = {
@@ -121,8 +92,8 @@ export class MySQLAdapter implements DriverAdapter {
private readonly transactionScope = new AsyncLocalStorage()
constructor(options: MySQLAdapterOptions = {}) {
- this.directClient = options.client ? wrapMySQLClient(options.client) : undefined
- this.pool = options.pool ? wrapMySQLPool(options.pool) : undefined
+ this.directClient = options.client
+ this.pool = options.pool
this.createPoolInstance = options.createPool ?? (options.client || options.pool
? undefined
: config => wrapMySQLPool(mysql.createPool(config)))
@@ -179,7 +150,6 @@ export class MySQLAdapter implements DriverAdapter {
return this.transactionScope.run({
client: this.directClient,
leased: false,
- released: false,
}, callback)
}
@@ -190,7 +160,6 @@ export class MySQLAdapter implements DriverAdapter {
const state: ScopedMySQLTransaction = {
client: await this.pool.getConnection(),
leased: true,
- released: false,
}
return this.transactionScope.run(state, async () => {
@@ -237,31 +206,31 @@ export class MySQLAdapter implements DriverAdapter {
async beginTransaction(): Promise {
const client = await this.leaseTransactionClient()
- await client.query('START TRANSACTION')
+ await client.query('START TRANSACTION', [])
}
async commit(): Promise {
const client = this.requireTransactionClient()
- await client.query('COMMIT')
+ await client.query('COMMIT', [])
this.releaseTransactionClient()
}
async rollback(): Promise {
const client = this.requireTransactionClient()
- await client.query('ROLLBACK')
+ await client.query('ROLLBACK', [])
this.releaseTransactionClient()
}
async createSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`)
+ await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`, [])
}
async rollbackToSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`)
+ await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`, [])
}
async releaseSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`)
+ await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`, [])
}
private async getQueryable(): Promise {
@@ -337,12 +306,11 @@ export class MySQLAdapter implements DriverAdapter {
}
private releaseScopedTransaction(state: ScopedMySQLTransaction): void {
- if (!state.leased || state.released) {
+ if (!state.leased) {
return
}
state.client.release?.()
- state.released = true
}
private normalizeSavepointName(name: string): string {
diff --git a/packages/db-mysql/tests/mysql.test.ts b/packages/db-mysql/tests/mysql.test.ts
index 799d0e69..78b904ce 100644
--- a/packages/db-mysql/tests/mysql.test.ts
+++ b/packages/db-mysql/tests/mysql.test.ts
@@ -1,7 +1,10 @@
import { randomUUID } from 'node:crypto'
import { describe, expect, it, vi } from 'vitest'
+import type { DriverAdapter } from '@holo-js/db'
import { createMySQLAdapter } from '../src'
+const runLiveMySql = process.env.HOLO_MYSQL_INTEGRATION === '1' ? it : it.skip
+
describe('@holo-js/db-mysql', () => {
it('supports direct clients without creating a pool', async () => {
const query = vi.fn(async (sql: string) => {
@@ -20,6 +23,7 @@ describe('@holo-js/db-mysql', () => {
end: vi.fn(async () => {}),
},
})
+ const canonicalAdapter: DriverAdapter = adapter
await expect(adapter.query('select 1')).resolves.toEqual({
rows: [{ sql: 'select 1' }],
@@ -34,9 +38,10 @@ describe('@holo-js/db-mysql', () => {
await adapter.rollback()
expect(query).toHaveBeenNthCalledWith(3, 'START TRANSACTION', [])
expect(query).toHaveBeenNthCalledWith(4, 'ROLLBACK', [])
+ void canonicalAdapter
})
- it('runs queries against a local MySQL server through the public adapter', async () => {
+ runLiveMySql('runs queries against a local MySQL server through the public adapter', async () => {
const tableName = `holo_real_usage_mysql_${randomUUID().replaceAll('-', '_')}`
const adapter = createMySQLAdapter({
config: {
diff --git a/packages/db-postgres/package.json b/packages/db-postgres/package.json
index aabb3416..7006b215 100644
--- a/packages/db-postgres/package.json
+++ b/packages/db-postgres/package.json
@@ -20,7 +20,8 @@
"build": "tsup",
"stub": "tsup --watch",
"typecheck": "tsc -p tsconfig.json --noEmit",
- "test": "vitest --run"
+ "test": "vitest --run",
+ "test:integration": "HOLO_POSTGRES_INTEGRATION=1 vitest --run tests/postgres.test.ts"
},
"peerDependencies": {
"@holo-js/db": "catalog:"
diff --git a/packages/db-postgres/src/index.ts b/packages/db-postgres/src/index.ts
index d14c40e8..cd48fd5e 100644
--- a/packages/db-postgres/src/index.ts
+++ b/packages/db-postgres/src/index.ts
@@ -1,36 +1,12 @@
import { AsyncLocalStorage } from 'node:async_hooks'
import { Pool, type PoolConfig, type QueryResult } from 'pg'
+import type {
+ DriverAdapter,
+ DriverExecutionResult,
+ DriverQueryResult,
+} from '@holo-js/db'
-export interface DriverQueryResult = Record> {
- rows: TRow[]
- rowCount: number
-}
-
-export interface DriverExecutionResult {
- affectedRows?: number
- lastInsertId?: number | string
-}
-
-export interface DriverAdapter {
- initialize(): Promise
- disconnect(): Promise
- isConnected(): boolean
- runWithTransactionScope?(callback: () => Promise): Promise
- query = Record>(
- sql: string,
- bindings?: readonly unknown[],
- ): Promise>
- execute(
- sql: string,
- bindings?: readonly unknown[],
- ): Promise
- beginTransaction(): Promise
- commit(): Promise
- rollback(): Promise
- createSavepoint?(name: string): Promise
- rollbackToSavepoint?(name: string): Promise
- releaseSavepoint?(name: string): Promise
-}
+export type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '@holo-js/db'
class TransactionError extends Error {}
diff --git a/packages/db-postgres/tests/postgres.test.ts b/packages/db-postgres/tests/postgres.test.ts
index 16a824bf..051e8cec 100644
--- a/packages/db-postgres/tests/postgres.test.ts
+++ b/packages/db-postgres/tests/postgres.test.ts
@@ -1,7 +1,10 @@
import { randomUUID } from 'node:crypto'
import { describe, expect, it, vi } from 'vitest'
+import type { DriverAdapter } from '@holo-js/db'
import { createPostgresAdapter } from '../src'
+const runLivePostgres = process.env.HOLO_POSTGRES_INTEGRATION === '1' ? it : it.skip
+
describe('@holo-js/db-postgres', () => {
it('supports direct clients without creating a pool', async () => {
const query = vi.fn(async (sql: string) => {
@@ -23,6 +26,7 @@ describe('@holo-js/db-postgres', () => {
end: vi.fn(async () => {}),
},
})
+ const canonicalAdapter: DriverAdapter = adapter
await expect(adapter.query('select 1')).resolves.toEqual({
rows: [{ sql: 'select 1' }],
@@ -37,9 +41,10 @@ describe('@holo-js/db-postgres', () => {
await adapter.commit()
expect(query).toHaveBeenNthCalledWith(3, 'BEGIN')
expect(query).toHaveBeenNthCalledWith(4, 'COMMIT')
+ void canonicalAdapter
})
- it('runs queries against a local Postgres server through the public adapter', async () => {
+ runLivePostgres('runs queries against a local Postgres server through the public adapter', async () => {
const tableName = `holo_real_usage_postgres_${randomUUID().replaceAll('-', '_')}`
const adapter = createPostgresAdapter({
config: {
diff --git a/packages/db-sqlite/src/index.ts b/packages/db-sqlite/src/index.ts
index 47938c70..d6c6a85d 100644
--- a/packages/db-sqlite/src/index.ts
+++ b/packages/db-sqlite/src/index.ts
@@ -1,35 +1,11 @@
import Database from 'better-sqlite3'
+import type {
+ DriverAdapter,
+ DriverExecutionResult,
+ DriverQueryResult,
+} from '@holo-js/db'
-export interface DriverQueryResult = Record> {
- rows: TRow[]
- rowCount: number
-}
-
-export interface DriverExecutionResult {
- affectedRows?: number
- lastInsertId?: number | string
-}
-
-export interface DriverAdapter {
- initialize(): Promise
- disconnect(): Promise
- isConnected(): boolean
- runWithTransactionScope?(callback: () => Promise): Promise
- query = Record>(
- sql: string,
- bindings?: readonly unknown[],
- ): Promise>
- execute(
- sql: string,
- bindings?: readonly unknown[],
- ): Promise
- beginTransaction(): Promise
- commit(): Promise
- rollback(): Promise
- createSavepoint?(name: string): Promise
- rollbackToSavepoint?(name: string): Promise
- releaseSavepoint?(name: string): Promise
-}
+export type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '@holo-js/db'
class TransactionError extends Error {}
@@ -112,7 +88,7 @@ export class SQLiteAdapter implements DriverAdapter {
bindings: readonly unknown[] = [],
): Promise> {
const statement = this.getDatabase().prepare(sql)
- const rows = this.invokeStatement(statement, 'all', bindings) as TRow[]
+ const rows = statement.all(...bindings) as TRow[]
return {
rows,
rowCount: rows.length,
@@ -131,7 +107,7 @@ export class SQLiteAdapter implements DriverAdapter {
bindings: readonly unknown[] = [],
): Promise {
const statement = this.getDatabase().prepare(sql)
- const result = this.invokeStatement(statement, 'run', bindings)
+ const result = statement.run(...bindings)
return {
affectedRows: result.changes,
lastInsertId: typeof result.lastInsertRowid === 'bigint'
@@ -180,32 +156,6 @@ export class SQLiteAdapter implements DriverAdapter {
return name
}
-
- private invokeStatement<
- TMethod extends 'all' | 'run',
- >(
- statement: SQLiteStatementLike,
- method: TMethod,
- bindings: readonly unknown[],
- ): ReturnType {
- try {
- return statement[method](...bindings) as ReturnType
- } catch (error) {
- if (bindings.length > 0 && this.isBindingArityError(error)) {
- return statement[method](bindings as never) as ReturnType
- }
-
- throw error
- }
- }
-
- private isBindingArityError(error: unknown): boolean {
- return error instanceof RangeError
- && (
- error.message.includes('Too many parameter values were provided')
- || error.message.includes('Too few parameter values were provided')
- )
- }
}
export function createSQLiteAdapter(options: SQLiteAdapterOptions = {}): SQLiteAdapter {
diff --git a/packages/db/package.json b/packages/db/package.json
index e46e3e9e..6c697471 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -47,8 +47,6 @@
"@holo-js/db-mysql": "catalog:",
"@holo-js/db-postgres": "catalog:",
"@holo-js/db-sqlite": "catalog:",
- "@types/better-sqlite3": "catalog:",
- "@types/pg": "catalog:",
"tsup": "catalog:",
"typescript": "catalog:"
}
diff --git a/packages/db/src/cache.ts b/packages/db/src/cache.ts
index bc323919..9f7bb352 100644
--- a/packages/db/src/cache.ts
+++ b/packages/db/src/cache.ts
@@ -20,13 +20,8 @@ export interface QueryCacheConfig {
readonly invalidate?: readonly string[]
}
-export interface NormalizedQueryCacheConfig {
- readonly ttl?: QueryCacheTtlInput
- readonly key?: string
- readonly driver?: string
- readonly flexible?: QueryCacheFlexibleTtlInput
- readonly invalidate?: readonly string[]
-}
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- preserve the exported interface shape while deriving from QueryCacheConfig.
+export interface NormalizedQueryCacheConfig extends QueryCacheConfig {}
export interface DatabaseQueryCacheBridge {
get(key: string, options?: { readonly driver?: string }): Promise
diff --git a/packages/db/src/core/QueryScheduler.ts b/packages/db/src/core/QueryScheduler.ts
index c509afbb..b5241b9b 100644
--- a/packages/db/src/core/QueryScheduler.ts
+++ b/packages/db/src/core/QueryScheduler.ts
@@ -14,6 +14,7 @@ type QueueState = {
active: number
queued: number
readonly limit: number
+ readonly waiters: Array<() => void>
}
export class QueryScheduler {
@@ -48,16 +49,19 @@ export class QueryScheduler {
active: 0,
queued: 0,
limit: concurrencyLimit,
+ waiters: [],
}
this.serializedState = {
active: 0,
queued: 0,
limit: 1,
+ waiters: [],
}
this.workerState = {
active: 0,
queued: 0,
limit: concurrencyLimit,
+ waiters: [],
}
}
@@ -71,6 +75,8 @@ export class QueryScheduler {
const schedulingMode = this.preview(options)
const state = this.resolveState(schedulingMode)
+ let slotReserved = false
+
if (state.active >= state.limit) {
if (state.queued >= this.queueLimit) {
throw new DatabaseError(
@@ -79,24 +85,13 @@ export class QueryScheduler {
)
}
- await new Promise((resolve) => {
- state.queued += 1
-
- const poll = () => {
- if (state.active < state.limit) {
- state.queued -= 1
- resolve()
- return
- }
-
- queueMicrotask(poll)
- }
-
- queueMicrotask(poll)
- })
+ await this.waitForSlot(state)
+ slotReserved = true
}
- state.active += 1
+ if (!slotReserved) {
+ state.active += 1
+ }
try {
return {
@@ -105,6 +100,7 @@ export class QueryScheduler {
}
} finally {
state.active -= 1
+ this.wakeNext(state)
}
}
@@ -145,6 +141,26 @@ export class QueryScheduler {
return this.serializedState
}
+
+ private waitForSlot(state: QueueState): Promise {
+ state.queued += 1
+
+ return new Promise((resolve) => {
+ state.waiters.push(() => {
+ state.queued -= 1
+ state.active += 1
+ resolve()
+ })
+ })
+ }
+
+ private wakeNext(state: QueueState): void {
+ if (state.active >= state.limit) {
+ return
+ }
+
+ state.waiters.shift()?.()
+ }
}
export function createQueryScheduler(options: QuerySchedulerOptions): QueryScheduler {
diff --git a/packages/db/src/drivers/MySQLAdapter.ts b/packages/db/src/drivers/MySQLAdapter.ts
deleted file mode 100644
index a7124730..00000000
--- a/packages/db/src/drivers/MySQLAdapter.ts
+++ /dev/null
@@ -1,328 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
-import mysql, {
- type Pool,
- type PoolConnection,
- type PoolOptions,
- type ResultSetHeader,
- type RowDataPacket,
-} from 'mysql2/promise'
-import { TransactionError } from '../core/errors'
-import type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '../core/types'
-
-export interface MySQLQueryableLike {
- query(sql: string, bindings?: readonly unknown[]): Promise
-}
-
-export interface MySQLClientLike extends MySQLQueryableLike {
- release?(): void
- end?(): Promise
-}
-
-export interface MySQLPoolLike extends MySQLQueryableLike {
- getConnection(): Promise
- end(): Promise
-}
-
-export interface MySQLAdapterOptions {
- uri?: string
- config?: PoolOptions
- client?: MySQLClientLike
- pool?: MySQLPoolLike
- createPool?: (config: PoolOptions) => MySQLPoolLike
-}
-
-type ScopedMySQLTransaction = {
- client: MySQLClientLike
- leased: boolean
- released: boolean
-}
-
-type RawMySQLClientLike = {
- query(sql: string, bindings?: unknown[]): Promise
- release?(): void
- end?(): Promise
-}
-
-type RawMySQLPoolLike = {
- query(sql: string, bindings?: unknown[]): Promise
- getConnection(): Promise
- end(): Promise
-}
-
-function toMutableBindings(bindings: readonly unknown[] = []): unknown[] {
- return [...bindings]
-}
-
-function wrapMySQLClient(client: PoolConnection | MySQLClientLike): MySQLClientLike {
- const rawClient = client as unknown as RawMySQLClientLike
-
- return {
- async query(sql: string, bindings: readonly unknown[] = []) {
- return rawClient.query(sql, toMutableBindings(bindings))
- },
- release: rawClient.release?.bind(rawClient),
- end: rawClient.end?.bind(rawClient),
- }
-}
-
-function wrapMySQLPool(pool: Pool | MySQLPoolLike): MySQLPoolLike {
- const rawPool = pool as unknown as RawMySQLPoolLike
-
- return {
- async query(sql: string, bindings: readonly unknown[] = []) {
- return rawPool.query(sql, toMutableBindings(bindings))
- },
- async getConnection() {
- return wrapMySQLClient(await rawPool.getConnection())
- },
- end: rawPool.end.bind(rawPool),
- }
-}
-
-export class MySQLAdapter implements DriverAdapter {
- private pool?: MySQLPoolLike
- private readonly directClient?: MySQLClientLike
- private readonly createPoolInstance?: (config: PoolOptions) => MySQLPoolLike
- private readonly config: PoolOptions
- private connected: boolean
- private transactionClient?: MySQLClientLike
- private leasedTransactionClient = false
- private readonly transactionScope = new AsyncLocalStorage()
-
- constructor(options: MySQLAdapterOptions = {}) {
- this.directClient = options.client ? wrapMySQLClient(options.client) : undefined
- this.pool = options.pool ? wrapMySQLPool(options.pool) : undefined
- this.createPoolInstance = options.createPool ?? (options.client || options.pool
- ? undefined
- : config => wrapMySQLPool(mysql.createPool(config)))
- this.config = options.config ?? (options.uri ? { uri: options.uri } as PoolOptions : {})
- this.connected = !!(options.client || options.pool)
- }
-
- async initialize(): Promise {
- if (this.connected) {
- return
- }
-
- if (this.createPoolInstance) {
- this.pool = this.createPoolInstance(this.config)
- }
-
- this.connected = true
- }
-
- async disconnect(): Promise {
- if (!this.connected) {
- return
- }
-
- if (this.transactionClient && this.leasedTransactionClient) {
- this.transactionClient.release?.()
- this.transactionClient = undefined
- this.leasedTransactionClient = false
- }
-
- if (this.pool) {
- await this.pool.end()
- this.pool = undefined
- } else if (this.directClient?.end) {
- await this.directClient.end()
- }
-
- this.connected = false
- }
-
- isConnected(): boolean {
- return this.connected
- }
-
- async runWithTransactionScope(callback: () => Promise): Promise {
- const active = this.transactionScope.getStore()
- if (active) {
- return callback()
- }
-
- await this.initialize()
-
- if (this.directClient) {
- return this.transactionScope.run({
- client: this.directClient,
- leased: false,
- released: false,
- }, callback)
- }
-
- if (!this.pool) {
- throw new TransactionError('MySQL adapter is not initialized with a pool or client.')
- }
-
- const state: ScopedMySQLTransaction = {
- client: await this.pool.getConnection(),
- leased: true,
- released: false,
- }
-
- return this.transactionScope.run(state, async () => {
- try {
- return await callback()
- } finally {
- this.releaseScopedTransaction(state)
- }
- })
- }
-
- async query = Record>(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise> {
- const queryable = await this.getQueryable()
- const [rows] = await queryable.query(sql, bindings)
- const normalized = rows as RowDataPacket[] & TRow[]
- return {
- rows: Array.isArray(normalized) ? [...normalized] : [],
- rowCount: Array.isArray(normalized) ? normalized.length : 0,
- }
- }
-
- async introspect = Record>(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise> {
- return this.query(sql, bindings)
- }
-
- async execute(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise {
- const queryable = await this.getQueryable()
- const [result] = await queryable.query(sql, bindings)
- const execution = result as ResultSetHeader
- return {
- affectedRows: typeof execution.affectedRows === 'number' ? execution.affectedRows : 0,
- lastInsertId: execution.insertId,
- }
- }
-
- async beginTransaction(): Promise {
- const client = await this.leaseTransactionClient()
- await client.query('START TRANSACTION')
- }
-
- async commit(): Promise {
- const client = this.requireTransactionClient()
- await client.query('COMMIT')
- this.releaseTransactionClient()
- }
-
- async rollback(): Promise {
- const client = this.requireTransactionClient()
- await client.query('ROLLBACK')
- this.releaseTransactionClient()
- }
-
- async createSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- async rollbackToSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- async releaseSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- private async getQueryable(): Promise {
- const scoped = this.transactionScope.getStore()
- if (scoped) {
- return scoped.client
- }
-
- if (this.transactionClient) {
- return this.transactionClient
- }
-
- await this.initialize()
-
- if (this.directClient) {
- return this.directClient
- }
-
- if (!this.pool) {
- throw new TransactionError('MySQL adapter is not initialized with a pool or client.')
- }
-
- return this.pool
- }
-
- private async leaseTransactionClient(): Promise {
- const scoped = this.transactionScope.getStore()
- if (scoped) {
- return scoped.client
- }
-
- if (this.transactionClient) {
- return this.transactionClient
- }
-
- await this.initialize()
-
- if (this.directClient) {
- this.transactionClient = this.directClient
- this.leasedTransactionClient = false
- return this.transactionClient
- }
-
- if (!this.pool) {
- throw new TransactionError('MySQL adapter is not initialized with a pool or client.')
- }
-
- this.transactionClient = await this.pool.getConnection()
- this.leasedTransactionClient = true
- return this.transactionClient
- }
-
- private requireTransactionClient(): MySQLClientLike {
- const scoped = this.transactionScope.getStore()
- if (scoped) {
- return scoped.client
- }
-
- if (!this.transactionClient) {
- throw new TransactionError('No active MySQL transaction client is available.')
- }
-
- return this.transactionClient
- }
-
- private releaseTransactionClient(): void {
- if (this.transactionClient && this.leasedTransactionClient) {
- this.transactionClient.release?.()
- }
-
- this.transactionClient = undefined
- this.leasedTransactionClient = false
- }
-
- private releaseScopedTransaction(state: ScopedMySQLTransaction): void {
- if (!state.leased || state.released) {
- return
- }
-
- state.client.release?.()
- state.released = true
- }
-
- private normalizeSavepointName(name: string): string {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- return name
- }
-}
-
-export function createMySQLAdapter(options: MySQLAdapterOptions = {}): MySQLAdapter {
- return new MySQLAdapter(options)
-}
diff --git a/packages/db/src/drivers/PostgresAdapter.ts b/packages/db/src/drivers/PostgresAdapter.ts
deleted file mode 100644
index 9b50d0c4..00000000
--- a/packages/db/src/drivers/PostgresAdapter.ts
+++ /dev/null
@@ -1,283 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
-import { Pool, type PoolConfig, type QueryResult } from 'pg'
-import { TransactionError } from '../core/errors'
-import type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '../core/types'
-
-export interface PostgresQueryableLike {
- query(sql: string, bindings?: readonly unknown[]): Promise> | {
- rows: Record[]
- rowCount?: number | null
- }>
-}
-
-export interface PostgresClientLike extends PostgresQueryableLike {
- release?(): void
- end?(): Promise
-}
-
-export interface PostgresPoolLike extends PostgresQueryableLike {
- connect(): Promise
- end(): Promise
-}
-
-export interface PostgresAdapterOptions {
- connectionString?: string
- config?: PoolConfig
- client?: PostgresClientLike
- pool?: PostgresPoolLike
- createPool?: (config?: PoolConfig) => PostgresPoolLike
-}
-
-type ScopedPostgresTransaction = {
- client: PostgresClientLike
- leased: boolean
- released: boolean
-}
-
-export class PostgresAdapter implements DriverAdapter {
- private pool?: PostgresPoolLike
- private readonly directClient?: PostgresClientLike
- private readonly createPoolInstance?: (config?: PoolConfig) => PostgresPoolLike
- private readonly config?: PoolConfig
- private connected: boolean
- private transactionClient?: PostgresClientLike
- private leasedTransactionClient = false
- private readonly transactionScope = new AsyncLocalStorage()
-
- constructor(options: PostgresAdapterOptions = {}) {
- this.directClient = options.client
- this.pool = options.pool
- this.createPoolInstance = options.createPool ?? (options.client || options.pool
- ? undefined
- : config => new Pool(config))
- this.config = options.config ?? (options.connectionString ? { connectionString: options.connectionString } : undefined)
- this.connected = !!(options.client || options.pool)
- }
-
- async initialize(): Promise {
- if (this.connected) {
- return
- }
-
- if (this.createPoolInstance) {
- this.pool = this.createPoolInstance(this.config)
- }
-
- this.connected = true
- }
-
- async disconnect(): Promise {
- if (!this.connected) {
- return
- }
-
- if (this.transactionClient && this.leasedTransactionClient) {
- this.transactionClient.release?.()
- this.transactionClient = undefined
- this.leasedTransactionClient = false
- }
-
- if (this.pool) {
- await this.pool.end()
- this.pool = undefined
- } else if (this.directClient?.end) {
- await this.directClient.end()
- }
-
- this.connected = false
- }
-
- isConnected(): boolean {
- return this.connected
- }
-
- async runWithTransactionScope(callback: () => Promise): Promise {
- const active = this.transactionScope.getStore()
- if (active) {
- return callback()
- }
-
- await this.initialize()
-
- if (this.directClient) {
- return this.transactionScope.run({
- client: this.directClient,
- leased: false,
- released: false,
- }, callback)
- }
-
- if (!this.pool) {
- throw new TransactionError('Postgres adapter is not initialized with a pool or client.')
- }
-
- const state: ScopedPostgresTransaction = {
- client: await this.pool.connect(),
- leased: true,
- released: false,
- }
-
- return this.transactionScope.run(state, async () => {
- try {
- return await callback()
- } finally {
- this.releaseScopedTransaction(state)
- }
- })
- }
-
- async query = Record>(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise> {
- const client = await this.getQueryable()
- const result = await client.query(sql, bindings)
- return {
- rows: result.rows as TRow[],
- rowCount: result.rowCount ?? result.rows.length,
- }
- }
-
- async introspect = Record>(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise> {
- return this.query(sql, bindings)
- }
-
- async execute(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise {
- const client = await this.getQueryable()
- const result = await client.query(sql, bindings)
- const firstRow = result.rows[0]
- const firstValue = firstRow ? Object.values(firstRow)[0] : undefined
- return {
- affectedRows: result.rowCount ?? 0,
- ...(typeof firstValue !== 'undefined' ? { lastInsertId: firstValue as number | string } : {}),
- }
- }
-
- async beginTransaction(): Promise {
- const client = await this.leaseTransactionClient()
- await client.query('BEGIN')
- }
-
- async commit(): Promise {
- const client = this.requireTransactionClient()
- await client.query('COMMIT')
- this.releaseTransactionClient()
- }
-
- async rollback(): Promise {
- const client = this.requireTransactionClient()
- await client.query('ROLLBACK')
- this.releaseTransactionClient()
- }
-
- async createSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- async rollbackToSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- async releaseSavepoint(name: string): Promise {
- await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- private async getQueryable(): Promise {
- const scoped = this.transactionScope.getStore()
- if (scoped) {
- return scoped.client
- }
-
- if (this.transactionClient) {
- return this.transactionClient
- }
-
- await this.initialize()
-
- if (this.directClient) {
- return this.directClient
- }
-
- if (!this.pool) {
- throw new TransactionError('Postgres adapter is not initialized with a pool or client.')
- }
-
- return this.pool
- }
-
- private async leaseTransactionClient(): Promise {
- const scoped = this.transactionScope.getStore()
- if (scoped) {
- return scoped.client
- }
-
- if (this.transactionClient) {
- return this.transactionClient
- }
-
- await this.initialize()
-
- if (this.directClient) {
- this.transactionClient = this.directClient
- this.leasedTransactionClient = false
- return this.transactionClient
- }
-
- if (!this.pool) {
- throw new TransactionError('Postgres adapter is not initialized with a pool or client.')
- }
-
- this.transactionClient = await this.pool.connect()
- this.leasedTransactionClient = true
- return this.transactionClient
- }
-
- private requireTransactionClient(): PostgresClientLike {
- const scoped = this.transactionScope.getStore()
- if (scoped) {
- return scoped.client
- }
-
- if (!this.transactionClient) {
- throw new TransactionError('No active Postgres transaction client is available.')
- }
-
- return this.transactionClient
- }
-
- private releaseTransactionClient(): void {
- if (this.transactionClient && this.leasedTransactionClient) {
- this.transactionClient.release?.()
- }
-
- this.transactionClient = undefined
- this.leasedTransactionClient = false
- }
-
- private releaseScopedTransaction(state: ScopedPostgresTransaction): void {
- if (!state.leased || state.released) {
- return
- }
-
- state.client.release?.()
- state.released = true
- }
-
- private normalizeSavepointName(name: string): string {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- return name
- }
-}
-
-export function createPostgresAdapter(options: PostgresAdapterOptions = {}): PostgresAdapter {
- return new PostgresAdapter(options)
-}
diff --git a/packages/db/src/drivers/SQLiteAdapter.ts b/packages/db/src/drivers/SQLiteAdapter.ts
deleted file mode 100644
index eddffe20..00000000
--- a/packages/db/src/drivers/SQLiteAdapter.ts
+++ /dev/null
@@ -1,182 +0,0 @@
-import Database from 'better-sqlite3'
-import { TransactionError } from '../core/errors'
-import type { DriverAdapter, DriverExecutionResult, DriverQueryResult } from '../core/types'
-
-export interface SQLiteStatementLike {
- all(...params: readonly unknown[]): Record[]
- run(...params: readonly unknown[]): { changes?: number, lastInsertRowid?: unknown }
-}
-
-export interface SQLiteDatabaseLike {
- prepare(sql: string): SQLiteStatementLike
- exec(sql: string): unknown
- close(): unknown
-}
-
-export interface SQLiteAdapterOptions {
- filename?: string
- database?: SQLiteDatabaseLike
- createDatabase?: (filename: string) => SQLiteDatabaseLike
-}
-
-export class SQLiteAdapter implements DriverAdapter {
- private database?: SQLiteDatabaseLike
- private connected: boolean
- private transactionTail: Promise = Promise.resolve()
- private readonly filename: string
- private readonly createDatabaseInstance: (filename: string) => SQLiteDatabaseLike
-
- constructor(options: SQLiteAdapterOptions = {}) {
- this.database = options.database
- this.connected = !!options.database
- this.filename = options.filename ?? ':memory:'
- this.createDatabaseInstance = options.createDatabase ?? (filename => new Database(filename))
- }
-
- async initialize(): Promise {
- if (this.connected) {
- return
- }
-
- this.database = this.createDatabaseInstance(this.filename)
- this.connected = true
- }
-
- async disconnect(): Promise {
- if (!this.connected || !this.database) {
- return
- }
-
- this.database.close()
- this.database = undefined
- this.connected = false
- }
-
- isConnected(): boolean {
- return this.connected
- }
-
- async runWithTransactionScope(callback: () => Promise): Promise {
- const previous = this.transactionTail
- let release!: () => void
- const current = previous.then(() => new Promise((resolve) => {
- release = resolve
- }))
- this.transactionTail = current
-
- await previous
-
- try {
- return await callback()
- } finally {
- release()
- if (this.transactionTail === current) {
- this.transactionTail = Promise.resolve()
- }
- }
- }
-
- async query = Record>(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise> {
- const statement = this.getDatabase().prepare(sql)
- const rows = this.invokeStatement(statement, 'all', bindings) as TRow[]
- return {
- rows,
- rowCount: rows.length,
- }
- }
-
- async introspect = Record>(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise> {
- return this.query(sql, bindings)
- }
-
- async execute(
- sql: string,
- bindings: readonly unknown[] = [],
- ): Promise {
- const statement = this.getDatabase().prepare(sql)
- const result = this.invokeStatement(statement, 'run', bindings)
- return {
- affectedRows: result.changes,
- lastInsertId: typeof result.lastInsertRowid === 'bigint'
- ? Number(result.lastInsertRowid)
- : result.lastInsertRowid as number | string | undefined,
- }
- }
-
- async beginTransaction(): Promise {
- this.getDatabase().exec('BEGIN')
- }
-
- async commit(): Promise {
- this.getDatabase().exec('COMMIT')
- }
-
- async rollback(): Promise {
- this.getDatabase().exec('ROLLBACK')
- }
-
- async createSavepoint(name: string): Promise {
- this.getDatabase().exec(`SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- async rollbackToSavepoint(name: string): Promise {
- this.getDatabase().exec(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- async releaseSavepoint(name: string): Promise {
- this.getDatabase().exec(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`)
- }
-
- private getDatabase(): SQLiteDatabaseLike {
- if (!this.connected || !this.database) {
- this.database = this.createDatabaseInstance(this.filename)
- this.connected = true
- }
-
- return this.database
- }
-
- private normalizeSavepointName(name: string): string {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- return name
- }
-
- private invokeStatement<
- TMethod extends 'all' | 'run',
- >(
- statement: SQLiteStatementLike,
- method: TMethod,
- bindings: readonly unknown[],
- ): ReturnType {
- try {
- return statement[method](...bindings) as ReturnType
- } catch (error) {
- if (bindings.length > 0 && this.isBindingArityError(error)) {
- return statement[method](bindings as never) as ReturnType
- }
-
- throw error
- }
- }
-
- private isBindingArityError(error: unknown): boolean {
- return error instanceof RangeError
- && (
- error.message.includes('Too many parameter values were provided')
- || error.message.includes('Too few parameter values were provided')
- )
- }
-}
-
-export function createSQLiteAdapter(options: SQLiteAdapterOptions = {}): SQLiteAdapter {
- return new SQLiteAdapter(options)
-}
diff --git a/packages/db/src/drivers/index.ts b/packages/db/src/drivers/index.ts
index 3bf81ec3..0aa6232d 100644
--- a/packages/db/src/drivers/index.ts
+++ b/packages/db/src/drivers/index.ts
@@ -1,5 +1,5 @@
-import { TransactionError } from '../core/errors'
import type { DriverAdapter, DriverExecutionResult, DriverQueryResult, DatabaseOperationOptions } from '../core/types'
+import { normalizeSavepointName } from './savepoints'
function isModuleNotFoundError(error: unknown): boolean {
return !!error
@@ -193,27 +193,15 @@ export class SQLiteAdapter extends LazyDriverAdapter {
}
override async createSavepoint(name: string, options?: DatabaseOperationOptions): Promise {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.createSavepoint(name, options)
+ await super.createSavepoint(normalizeSavepointName(name), options)
}
override async rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.rollbackToSavepoint(name, options)
+ await super.rollbackToSavepoint(normalizeSavepointName(name), options)
}
override async releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.releaseSavepoint(name, options)
+ await super.releaseSavepoint(normalizeSavepointName(name), options)
}
}
@@ -282,40 +270,16 @@ export class PostgresAdapter {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.createSavepoint(name, options)
+ await super.createSavepoint(normalizeSavepointName(name), options)
}
override async rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.rollbackToSavepoint(name, options)
+ await super.rollbackToSavepoint(normalizeSavepointName(name), options)
}
override async releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.releaseSavepoint(name, options)
+ await super.releaseSavepoint(normalizeSavepointName(name), options)
}
}
@@ -383,40 +347,16 @@ export class MySQLAdapter {
- if (!/^[A-Z_]\w*$/i.test(name)) {
- throw new TransactionError(`Invalid savepoint name "${name}".`)
- }
-
- await super.createSavepoint(name, options)
+ await super.createSavepoint(normalizeSavepointName(name), options)
}
override async rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise