ts-procedures 7.1.2 → 7.3.0

package/src/implementations/http/astro/index.test.ts

@@ -0,0 +1,350 @@
+import { describe, expect, test } from 'vitest'
+import { Hono } from 'hono'
+import { Type } from 'typebox'
+import { stripPrefix } from './rewrite-request.js'
+import { setAstroContext, getAstroContext } from './astro-context.js'
+import { createAstroHandler } from './create-handler.js'
+import { Procedures } from '../../../index.js'
+import { HonoAPIAppBuilder } from '../hono-api/index.js'
+import { HonoStreamAppBuilder } from '../hono-stream/index.js'
+import type { APIConfig, RPCConfig } from '../../types.js'
+
+// Minimal stand-in for Astro's APIContext for unit tests.
+function fakeApiContext(overrides: Record<string, unknown> = {}) {
+  return {
+    locals: { user: { id: 'u-1' } },
+    cookies: {},
+    params: {},
+    request: new Request('https://example.test/'),
+    url: new URL('https://example.test/'),
+    redirect: () => new Response(null, { status: 302 }),
+    ...overrides,
+  } as unknown as import('astro').APIContext
+}
+
+function buildSimpleUserApi() {
+  const API = Procedures<{ db: Map<string, { id: string; name: string }> }, APIConfig>()
+  API.Create(
+    'GetUser',
+    {
+      path: '/users/:id',
+      method: 'get',
+      schema: {
+        input: { pathParams: Type.Object({ id: Type.String() }) },
+        returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+      },
+    },
+    async (ctx, { pathParams }) => {
+      const u = ctx.db.get(pathParams.id)
+      if (!u) throw new Error('not found')
+      return u
+    }
+  )
+  const db = new Map([['1', { id: '1', name: 'Ada' }]])
+  return new HonoAPIAppBuilder().register(API, () => ({ db })).build()
+}
+
+describe('stripPrefix', () => {
+  test('returns original request when prefix is undefined', () => {
+    const req = new Request('https://example.test/api/users/1')
+    expect(stripPrefix(req, undefined)).toBe(req)
+  })
+
+  test('returns original request when normalized prefix is "/"', () => {
+    const req = new Request('https://example.test/users/1')
+    expect(stripPrefix(req, '/')).toBe(req)
+    expect(stripPrefix(req, '')).toBe(req)
+  })
+
+  test('strips a leading-slash prefix', () => {
+    const req = new Request('https://example.test/api/users/1')
+    const out = stripPrefix(req, '/api')!
+    expect(new URL(out.url).pathname).toBe('/users/1')
+  })
+
+  test('strips a no-slash prefix (normalized)', () => {
+    const req = new Request('https://example.test/api/users/1')
+    const out = stripPrefix(req, 'api')!
+    expect(new URL(out.url).pathname).toBe('/users/1')
+  })
+
+  test('strips a trailing-slash prefix (normalized)', () => {
+    const req = new Request('https://example.test/api/users/1')
+    const out = stripPrefix(req, '/api/')!
+    expect(new URL(out.url).pathname).toBe('/users/1')
+  })
+
+  test('exact-match prefix becomes "/"', () => {
+    const req = new Request('https://example.test/api')
+    const out = stripPrefix(req, '/api')!
+    expect(new URL(out.url).pathname).toBe('/')
+  })
+
+  test('returns null when path does not start with prefix (404 short-circuit)', () => {
+    const req = new Request('https://example.test/other/users/1')
+    expect(stripPrefix(req, '/api')).toBeNull()
+  })
+
+  test('returns null when path shares prefix characters but not a segment boundary', () => {
+    // /apikey starts with /api but is not under /api — must NOT rewrite.
+    expect(stripPrefix(new Request('https://example.test/apikey/secret'), '/api')).toBeNull()
+    expect(stripPrefix(new Request('https://example.test/api-v2/x'), '/api')).toBeNull()
+    expect(stripPrefix(new Request('https://example.test/api_internal'), '/api')).toBeNull()
+  })
+
+  test('preserves the query string through the rewrite', () => {
+    const req = new Request('https://example.test/api/users?limit=10&tag=a&tag=b')
+    const out = stripPrefix(req, '/api')!
+    const url = new URL(out.url)
+    expect(url.pathname).toBe('/users')
+    expect(url.search).toBe('?limit=10&tag=a&tag=b')
+  })
+
+  test('preserves the request method', () => {
+    const req = new Request('https://example.test/api/users', { method: 'POST' })
+    const out = stripPrefix(req, '/api')!
+    expect(out.method).toBe('POST')
+  })
+
+  test('preserves headers', () => {
+    const req = new Request('https://example.test/api/users', {
+      method: 'POST',
+      headers: { 'X-Trace-Id': 'abc-123', 'Content-Type': 'application/json' },
+    })
+    const out = stripPrefix(req, '/api')!
+    expect(out.headers.get('X-Trace-Id')).toBe('abc-123')
+    expect(out.headers.get('Content-Type')).toBe('application/json')
+  })
+})
+
+describe('astro-context', () => {
+  test('getAstroContext returns the APIContext stashed for the request seen by Hono', async () => {
+    const req = new Request('https://example.test/probe')
+    const apiContext = fakeApiContext()
+    setAstroContext(req, apiContext)
+
+    const app = new Hono()
+    let observed: import('astro').APIContext | null = null
+    app.get('/probe', (c) => {
+      observed = getAstroContext(c)
+      return c.json({ ok: true })
+    })
+
+    const res = await app.fetch(req)
+    expect(res.status).toBe(200)
+    expect(observed).toBe(apiContext)
+  })
+
+  test('getAstroContext throws when called outside an Astro request scope', async () => {
+    const app = new Hono()
+    let captured: unknown = null
+    app.get('/probe', (c) => {
+      try {
+        getAstroContext(c)
+      } catch (err) {
+        captured = err
+      }
+      return c.json({ ok: true })
+    })
+
+    await app.fetch(new Request('https://example.test/probe'))
+    expect(captured).toBeInstanceOf(Error)
+    expect((captured as Error).message).toMatch(/outside an Astro request scope/i)
+  })
+})
+
+describe('createAstroHandler — single app, no prefix', () => {
+  test('exports ALL plus the seven HTTP method handlers', () => {
+    const handlers = createAstroHandler({ apps: buildSimpleUserApi() })
+    expect(typeof handlers.ALL).toBe('function')
+    for (const m of ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] as const) {
+      expect(typeof handlers[m]).toBe('function')
+    }
+  })
+
+  test('GET roundtrips through the underlying Hono app', async () => {
+    const { ALL } = createAstroHandler({ apps: buildSimpleUserApi() })
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/users/1'),
+      url: new URL('https://example.test/users/1'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ id: '1', name: 'Ada' })
+  })
+})
+
+describe('createAstroHandler — pathPrefix + getAstroContext', () => {
+  test('strips pathPrefix before delegating', async () => {
+    // Underlying Hono app has no /api in its routes.
+    const app = buildSimpleUserApi()
+    const { ALL } = createAstroHandler({ apps: app, pathPrefix: '/api' })
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/api/users/1'),
+      url: new URL('https://example.test/api/users/1'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ id: '1', name: 'Ada' })
+  })
+
+  test('returns 404 directly when request path is outside the prefix', async () => {
+    const { ALL } = createAstroHandler({ apps: buildSimpleUserApi(), pathPrefix: '/api' })
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/somewhere-else'),
+      url: new URL('https://example.test/somewhere-else'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(404)
+  })
+
+  test('factory closure can read APIContext via getAstroContext', async () => {
+    const API = Procedures<{ user: { id: string } | null }, APIConfig>()
+    API.Create(
+      'WhoAmI',
+      { path: '/whoami', method: 'get', schema: { returnType: Type.Object({ userId: Type.Union([Type.String(), Type.Null()]) }) } },
+      async (ctx) => ({ userId: ctx.user?.id ?? null })
+    )
+
+    const app = new HonoAPIAppBuilder()
+      .register(API, (c) => {
+        const astro = getAstroContext(c)
+        return { user: (astro.locals as { user?: { id: string } }).user ?? null }
+      })
+      .build()
+
+    const { ALL } = createAstroHandler({ apps: app })
+    const apiContext = fakeApiContext({
+      locals: { user: { id: 'u-42' } },
+      request: new Request('https://example.test/whoami'),
+      url: new URL('https://example.test/whoami'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ userId: 'u-42' })
+  })
+})
+
+describe('createAstroHandler — multi-app dispatch', () => {
+  function makeAppWithRoute(path: string, status: number, body: unknown) {
+    const app = new Hono()
+    app.all(path, (c) => c.json(body, status as any))
+    return app
+  }
+
+  test('first 404 falls through to the second app', async () => {
+    const a = makeAppWithRoute('/only-a', 200, { from: 'a' })
+    const b = makeAppWithRoute('/only-b', 200, { from: 'b' })
+    const { ALL } = createAstroHandler({ apps: [a, b] })
+
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/only-b'),
+      url: new URL('https://example.test/only-b'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ from: 'b' })
+  })
+
+  test('a non-404 response from the first app short-circuits dispatch', async () => {
+    const a = makeAppWithRoute('/error', 500, { boom: true })
+    const b = makeAppWithRoute('/error', 200, { from: 'b' })
+    const { ALL } = createAstroHandler({ apps: [a, b] })
+
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/error'),
+      url: new URL('https://example.test/error'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(500)
+    expect(await res.json()).toEqual({ boom: true })
+  })
+
+  test('all-404 returns the adapter\'s own 404 with empty body', async () => {
+    const a = makeAppWithRoute('/x', 200, { from: 'a' })
+    const b = makeAppWithRoute('/y', 200, { from: 'b' })
+    const { ALL } = createAstroHandler({ apps: [a, b] })
+
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/nope'),
+      url: new URL('https://example.test/nope'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(404)
+    expect(await res.text()).toBe('')
+  })
+})
+
+describe('createAstroHandler — streams', () => {
+  test('SSE events from a HonoStream builder pass through the adapter', async () => {
+    const STREAM = Procedures<{}, RPCConfig>()
+    STREAM.CreateStream(
+      'Counter',
+      {
+        scope: 'counter',
+        version: 1,
+        schema: {
+          yieldType: Type.Object({ n: Type.Number() }),
+        },
+      },
+      async function* () {
+        yield { n: 1 }
+        yield { n: 2 }
+        yield { n: 3 }
+      }
+    )
+
+    const streamApp = new HonoStreamAppBuilder().register(STREAM, () => ({})).build()
+    const { ALL } = createAstroHandler({ apps: streamApp })
+
+    const apiContext = fakeApiContext({
+      request: new Request('https://example.test/counter/counter/1', { method: 'GET' }),
+      url: new URL('https://example.test/counter/counter/1'),
+    })
+    const res = await ALL(apiContext)
+    expect(res.status).toBe(200)
+    expect(res.headers.get('content-type')).toContain('text/event-stream')
+
+    // Drain the SSE body and assert all three events appear in order.
+    const text = await res.text()
+    expect(text).toContain('event: Counter')
+    expect(text).toContain('data: {"n":1}')
+    expect(text).toContain('data: {"n":2}')
+    expect(text).toContain('data: {"n":3}')
+  })
+})
+
+describe('createAstroHandler — abort signal', () => {
+  test("aborting the incoming request aborts the procedure handler's ctx.signal", async () => {
+    let observedSignal: AbortSignal | undefined
+    const aborted = new Promise<void>((resolve) => {
+      const API = Procedures<{}, APIConfig>()
+      API.Create(
+        'Hang',
+        { path: '/hang', method: 'get', schema: { returnType: Type.Object({ ok: Type.Boolean() }) } },
+        async (ctx) => {
+          observedSignal = ctx.signal
+          ctx.signal?.addEventListener('abort', () => resolve(), { once: true })
+          // Wait for abort or a generous timeout.
+          await new Promise<void>((r) => setTimeout(r, 200))
+          return { ok: true }
+        }
+      )
+      const app = new HonoAPIAppBuilder().register(API, () => ({})).build()
+      const { ALL } = createAstroHandler({ apps: app })
+
+      const controller = new AbortController()
+      const apiContext = fakeApiContext({
+        request: new Request('https://example.test/hang', { signal: controller.signal }),
+        url: new URL('https://example.test/hang'),
+      })
+
+      // Fire ALL but don't await — abort while the handler is still running.
+      ;(ALL(apiContext) as Promise<Response>).catch(() => {})
+      setTimeout(() => controller.abort(), 20)
+    })
+
+    await aborted
+    expect(observedSignal?.aborted).toBe(true)
+  })
+})

package/src/implementations/http/astro/index.ts

@@ -0,0 +1,6 @@
+// Public surface for ts-procedures/astro.
+// Note: setAstroContext is intentionally NOT re-exported — it's an
+// internal helper used only by createAstroHandler.
+export { createAstroHandler } from './create-handler.js'
+export type { AstroAdapterConfig, AstroHandlers } from './create-handler.js'
+export { getAstroContext } from './astro-context.js'

package/src/implementations/http/astro/rewrite-request.ts

@@ -0,0 +1,31 @@
+/**
+ * Returns a Request with `prefix` stripped from the URL pathname.
+ *
+ * - `prefix` undefined or normalizing to '/' → returns the original request unchanged.
+ * - Path does not start with the normalized prefix at a segment boundary → returns `null`
+ *   (caller short-circuits to 404). E.g. with prefix '/api', the request '/apikey'
+ *   returns null because 'key' is not preceded by a path separator.
+ * - Otherwise → returns a new Request with the rewritten URL and method/headers/body/signal/duplex
+ *   preserved via `new Request(url, init)`.
+ *
+ * Normalization: leading and trailing slashes are optional. '/api', 'api', and '/api/' are equivalent.
+ */
+export function stripPrefix(request: Request, prefix: string | undefined): Request | null {
+  if (prefix === undefined) return request
+  const normalized = '/' + prefix.replace(/^\/|\/$/g, '')
+  if (normalized === '/') return request
+
+  const url = new URL(request.url)
+  if (!url.pathname.startsWith(normalized)) return null
+
+  // Segment-boundary guard: the character right after the prefix in the path
+  // MUST be either undefined (exact match) or '/' (real segment boundary).
+  // Without this, '/apikey' would falsely match prefix '/api'.
+  const nextChar = url.pathname[normalized.length]
+  if (nextChar !== undefined && nextChar !== '/') return null
+
+  const rest = url.pathname.slice(normalized.length)
+  url.pathname = rest === '' ? '/' : rest
+
+  return new Request(url, request)
+}

package/src/index.test.ts

@@ -1220,3 +1220,174 @@ describe('isPrevalidated context property', () => {
     })
   })
 })
+
+describe('builder.config.noRuntimeValidation', () => {
+  test('Create skips params validation when noRuntimeValidation is true', async () => {
+    const { Create } = Procedures({ config: { noRuntimeValidation: true } })
+
+    const { SkipParams } = Create(
+      'SkipParams',
+      {
+        schema: {
+          params: Type.Object({ name: Type.String() }),
+        },
+      },
+      async (_ctx, params) => params
+    )
+
+    // Missing required `name` would normally throw ProcedureValidationError
+    const result = await SkipParams({}, {} as any)
+    expect(result).toEqual({})
+  })
+
+  test('Create skips input channel validation when noRuntimeValidation is true', async () => {
+    const { Create } = Procedures({ config: { noRuntimeValidation: true } })
+
+    const { SkipInput } = Create(
+      'SkipInput',
+      {
+        schema: {
+          input: {
+            pathParams: Type.Object({ id: Type.String() }),
+            body: Type.Object({ name: Type.String() }),
+          },
+        },
+      },
+      async (_ctx, params) => params
+    )
+
+    // Both channels missing required fields — normally throws on the first one
+    const result = await SkipInput(
+      {},
+      { pathParams: {}, body: {} } as any
+    )
+    expect(result).toEqual({ pathParams: {}, body: {} })
+  })
+
+  test('Create still validates when noRuntimeValidation is omitted', async () => {
+    const { Create } = Procedures({ config: {} })
+
+    const { ValidateDefault } = Create(
+      'ValidateDefault',
+      {
+        schema: {
+          params: Type.Object({ name: Type.String() }),
+        },
+      },
+      async (_ctx, params) => params
+    )
+
+    await expect(ValidateDefault({}, {} as any)).rejects.toBeInstanceOf(ProcedureValidationError)
+  })
+
+  test('Create validates when builder is omitted entirely', async () => {
+    const { Create } = Procedures()
+
+    const { ValidateNoBuilder } = Create(
+      'ValidateNoBuilder',
+      {
+        schema: {
+          params: Type.Object({ name: Type.String() }),
+        },
+      },
+      async (_ctx, params) => params
+    )
+
+    await expect(ValidateNoBuilder({}, {} as any)).rejects.toBeInstanceOf(
+      ProcedureValidationError
+    )
+  })
+
+  test('CreateStream skips params validation when noRuntimeValidation is true', async () => {
+    const { CreateStream } = Procedures({ config: { noRuntimeValidation: true } })
+
+    const { StreamSkipParams } = CreateStream(
+      'StreamSkipParams',
+      {
+        schema: {
+          params: Type.Object({ count: Type.Number() }),
+        },
+      },
+      async function* (_ctx, params) {
+        yield { received: params }
+      }
+    )
+
+    const values: any[] = []
+    for await (const val of StreamSkipParams({}, {} as any)) {
+      values.push(val)
+    }
+
+    expect(values).toEqual([{ received: {} }])
+  })
+
+  test('CreateStream skips input channel validation when noRuntimeValidation is true', async () => {
+    const { CreateStream } = Procedures({ config: { noRuntimeValidation: true } })
+
+    const { StreamSkipInput } = CreateStream(
+      'StreamSkipInput',
+      {
+        schema: {
+          input: {
+            pathParams: Type.Object({ id: Type.String() }),
+          },
+        },
+      },
+      async function* (_ctx, params) {
+        yield params
+      }
+    )
+
+    const values: any[] = []
+    for await (const val of StreamSkipInput({}, { pathParams: {} } as any)) {
+      values.push(val)
+    }
+
+    expect(values).toEqual([{ pathParams: {} }])
+  })
+
+  test('CreateStream still validates when noRuntimeValidation is omitted', async () => {
+    const { CreateStream } = Procedures({ config: {} })
+
+    const { StreamValidateDefault } = CreateStream(
+      'StreamValidateDefault',
+      {
+        schema: {
+          params: Type.Object({ count: Type.Number() }),
+        },
+      },
+      async function* (_ctx, params) {
+        yield params
+      }
+    )
+
+    await expect(async () => {
+      for await (const _v of StreamValidateDefault({}, {} as any)) {
+        // consume
+      }
+    }).rejects.toBeInstanceOf(ProcedureValidationError)
+  })
+
+  test('noRuntimeValidation does not interfere with onCreate callback', async () => {
+    const seen: string[] = []
+    const { Create } = Procedures({
+      config: { noRuntimeValidation: true },
+      onCreate: (proc) => {
+        seen.push(proc.name)
+      },
+    })
+
+    Create(
+      'Registered',
+      { schema: { params: Type.Object({ id: Type.String() }) } },
+      async (_ctx, params) => params
+    )
+
+    expect(seen).toEqual(['Registered'])
+  })
+
+  test('noRuntimeValidation: false is rejected by the type system', () => {
+    // @ts-expect-error - only `true` (or omitted) is allowed for noRuntimeValidation
+    void Procedures({ config: { noRuntimeValidation: false } })
+  })
+})

package/src/index.ts

@@ -58,11 +58,22 @@ export type TStreamProcedureRegistration<TContext = unknown, TExtendedConfig = u
   handler: (ctx: TContext, params?: any) => AsyncGenerator<any, any, unknown>
 }
 
+export type TBuilderConfig = {
+  /**
+   * The default is to validate schema inputs at runtime, to disable pass `true` for this property.
+   *
+   * @Note: this is not recommended for public unknown data, only use for internal procedure
+   * factories with type-checking build steps.
+   */
+  noRuntimeValidation?: true
+}
+
 export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unknown>(
   /**
    * Optionally provided builder to register Procedures
    */
   builder?: {
+    config?: TBuilderConfig
     onCreate?: (
       procedure: Prettify<{
         name: string
@@ -148,9 +159,12 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
 
       handler: async (ctx: Prettify<TContext>, params: TSchemaLib<TParams>) => {
         try {
-          // Skip validation if caller has already validated (e.g., HonoStreamAppBuilder)
-          const isPrevalidated = (ctx as { isPrevalidated?: boolean }).isPrevalidated
-          if (validations?.params && !isPrevalidated) {
+          // Skip validation if caller has already validated (e.g., HonoStreamAppBuilder) or if builder config dictates noRuntimeValidation
+          const skipValidation =
+            (ctx as { isPrevalidated?: boolean }).isPrevalidated ||
+            builder?.config?.noRuntimeValidation
+
+          if (validations?.params && !skipValidation) {
             const { errors } = validations.params(params)
 
             if (errors) {
@@ -166,7 +180,7 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
           // Validate each input channel independently for better error messages.
           // Double validation (per-channel + merged) is intentional for developer experience;
           // the cost is negligible — revisit if validation becomes a performance bottleneck.
-          if (validations?.input && !isPrevalidated) {
+          if (validations?.input && !skipValidation) {
             for (const [channel, validator] of Object.entries(validations.input)) {
               const channelValue = (params as Record<string, unknown>)?.[channel]
               const { errors } = validator(channelValue)
@@ -330,9 +344,12 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
         // Create abort controller for this stream
         const abortController = new AbortController()
 
-        // Skip validation if caller has already validated (e.g., HonoStreamAppBuilder)
-        const isPrevalidated = (ctx as { isPrevalidated?: boolean }).isPrevalidated
-        if (validations?.params && !isPrevalidated) {
+        // Skip validation if caller has already validated (e.g., HonoStreamAppBuilder) or if builder config dictates noRuntimeValidation
+        const skipValidation =
+          (ctx as { isPrevalidated?: boolean }).isPrevalidated ||
+          builder?.config?.noRuntimeValidation
+
+        if (validations?.params && !skipValidation) {
           const { errors } = validations.params(params)
 
           if (errors) {
@@ -346,7 +363,7 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
         }
 
         // Validate each input channel independently (see Create for rationale)
-        if (validations?.input && !isPrevalidated) {
+        if (validations?.input && !skipValidation) {
           for (const [channel, validator] of Object.entries(validations.input)) {
             const channelValue = (params as Record<string, unknown>)?.[channel]
             const { errors } = validator(channelValue)
@@ -416,14 +433,9 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
           // user-defined errors inside ProcedureError defeats route-declared
           // typed-error dispatch on the client. Augment the stack trace in
           // place with the procedure's definition site when available.
-          if (
-            definitionInfo.definedAt &&
-            error &&
-            typeof error.stack === 'string'
-          ) {
+          if (definitionInfo.definedAt && error && typeof error.stack === 'string') {
             const { file, line, column } = definitionInfo.definedAt
-            error.stack =
-              `${error.stack}\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`
+            error.stack = `${error.stack}\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`
           }
           throw error
         } finally {