@sugardarius/anzen 1.1.2 → 2.0.0

package/README.md

@@ -1,4 +1,4 @@
-A flexible, framework validation agnostic, type-safe factory for creating Next.JS App Router route handlers.
+A fast, framework validation agnostic, type-safe factories for creating route handlers, page and layout server components files in Next.js.
 
 - 🔧 Framework validation agnostic, use a validation library of your choice supporting [Standard Schema](https://standardschema.dev/).
 - 🧠 Focused functionalities, use only features you want.
@@ -15,6 +15,8 @@ npm i @sugardarius/anzen
 
 ## Usage
 
+### Route Handlers
+
 ```tsx
 import { object, string, number } from 'decoders'
 import { createSafeRouteHandler } from '@sugardarius/anzen'
@@ -35,469 +37,205 @@ export const POST = createSafeRouteHandler(
       bar: number,
     }),
   },
-  async ({ auth, body }, req): Promise<Response> => {
-    return Response.json({ user: auth.user, body }, { status: 200 })
-  }
-)
-```
-
-The example above shows how to use the factory to authorize your requests.
-
-## Framework validation agnostic
-
-By design the factory is framework validation agnostic 🌟. When doing your validations you can use whatever you want as framework validation as long as it implements the [Standard Schema](https://github.com/standard-schema/standard-schema) common interface. You can use your favorite validation library like [Zod](https://zod.dev/), [Validbot](https://valibot.dev/) or [decoders](https://decoders.cc/).
-
-```tsx
-// (POST) /app/api/races/[id]/route.ts
-import { z } from 'zod'
-import { object, string, number } from 'decoders'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const POST = createSafeRouteHandler(
-  {
-    // `zod` for segments dictionary validation
-    segments: { id: z.string() }
-    // `decoders` for body validation
-    body: object({
-      id: number,
-      name: string,
-    }),
-  },
-  async ({ segments, body }) => {
-    return Response.json({ segments, body })
-  }
-)
-```
-
-## Synchronous validations
-
-The factory do not supports async validations. As required by the [Standard Schema](https://github.com/standard-schema/standard-schema) common interface we should avoid it. In the context of a route handler it's not necessary.
-
-If you define an async validation then the route handler will throw an error.
-
-## API
-
-Check the API and the available options to configure the factory as you wish.
-
-### Function signature
-
-```tsx
-import {
-  type CreateSafeRouteHandlerOptions,
-  type SafeRouteHandlerContext,
-  createSafeRouteHandler
-} from '@sugardarius/anzen'
-
-/**
- * Returns a Next.js API route handler function.
- */
-export const VERB = createSafeRouteHandler(
-  /**
-   * Options to configure the route handler
-   */
-  options: CreateSafeRouteHandlerOptions,
-  /**
-   * The route handler function.
-   */
   async (
-    /**
-     * Context object providing:
-     *  auth context
-     *  validated segments, search params, body and form data
-     */
-    ctx: SafeRouteHandlerContext,
-    /**
-     * Original request
-     */
-    req: Request
-): Promise<Response> => Response.json({}))
-```
-
-### Using `NextRequest` type
-
-By default the factory uses the native `Request` type. If you want to use the `NextRequest` type from [Next.js](https://nextjs.org/), you can do it by just using the `NextRequest` type in the factory handler.
-
-```tsx
-import { NextRequest } from 'next/server'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const GET = createSafeRouteHandler(
-  {
-    id: 'next/request',
-    authorize: async ({
-      // Due to `NextRequest` limitations as the req is cloned it's always a `Request`
-      req,
-    }) => {
-      console.log(req)
-      return { user: 'John Doe' }
+    {
+      auth, // Auth context is inferred from the authorize function
+      body, // Body is inferred from the body validation
     },
-  },
-  async (ctx, req: NextRequest) => {
-    console.log('pathname', req.nextUrl.pathname)
-    return new Response(null, 200)
-  }
-)
-```
-
-### Base options
-
-When creating a safe route handler you can use a bunch of options for helping you achieve different tasks 👇🏻
-
-#### `id?: string`
-
-Used for logging in development or when the `debug` option is enabled. You can also use it to add extra logging or monitoring.
-By default the id is set to `[unknown:route:handler]`
-
-```tsx
-export const POST = createSafeRouteHandler(
-  {
-    id: 'auth/login',
-  },
-  async ({ id }) => {
-    return Response.json({ id })
+    req
+  ): Promise<Response> => {
+    return Response.json({ user: auth.user, body }, { status: 200 })
   }
 )
 ```
 
-#### `authorize?: AuthFunction<AC>`
-
-Function to use to authorize the request. By default it always authorize the request.
-
-Returns a response when the request is not authorized.
+### Page Server Components
 
 ```tsx
-import { createSafeRouteHandler } from '@sugardarius/anzen'
+import { object, string, number } from 'decoders'
+import { unauthorized } from 'next/navigation'
+import { createSafePageServerComponent } from '@sugardarius/anzen/server-components'
 import { auth } from '~/lib/auth'
 
-export const GET = createSafeRouteHandler(
+export default createSafePageServerComponent(
   {
-    authorize: async ({ req, url }) => {
-      console.log('url', url)
-      const session = await auth.getSession(req)
+    authorize: async ({ segments }) => {
+      const session = await auth.getSession()
       if (!session) {
-        return new Response(null, { status: 401 })
+        unauthorized()
       }
 
       return { user: session.user }
     },
-  },
-  async ({ auth, body }, req): Promise<Response> => {
-    return Response.json({ user: auth.user }, { status: 200 })
-  }
-)
-```
-
-The original is cloned from the incoming request to avoid side effects and to make it consumable in the `authorize` function.
-
-#### `onErrorResponse?: (err: unknown) => Awaitable<Response>`
-
-Callback triggered when the request fails.
-By default it returns a simple `500` response and the error is logged into the console.
-
-Use it if your handler use custom errors and you want to manage them properly by returning a proper response.
-
-You can read more about it under the [Error handling](#error-handling) section.
-
-#### `debug?: boolean`
-
-Use this options to enable debug mode. It will add logs in the handler to help you debug the request.
-
-By default it's set to `false` for production builds.
-In development builds, it will be `true` if `NODE_ENV` is not set to `production`.
-
-```tsx
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const GET = createSafeRouteHandler({ debug: true }, async () => {
-  return new Response(null, { status: 200 })
-})
-```
-
-### Route handler options
-
-You can configure route handler options to validation using a validation library dynamic route segments, URL query parameters, request json body or request form data body 👇🏻
-
-#### `segments?: TSegments`
-
-[Dynamic route segments](https://nextjs.org/docs/app/building-your-application/routing/route-handlers#dynamic-route-segments) used for the route handler path. By design it will handle if the segments are a `Promise` or not.
-
-Please note the expected input is a `StandardSchemaDictionary`.
-
-```tsx
-import { z } from 'zod'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const GET = createSafeRouteHandler(
-  {
     segments: {
-      accountId: z.string(),
-      projectId: z.string().optional(),
+      id: string,
+    },
+    searchParams: {
+      page: number,
     },
   },
-  async ({ segments }) => {
-    return Response.json({ segments })
+  async ({
+    auth, // Auth context is inferred from the authorize function
+    segments, // Segments are inferred from the segments validation
+    searchParams, // Search params are inferred from the searchParams validation
+  }) => {
+    return <div>Hello {auth.user.name}!</div>
   }
 )
 ```
 
-#### `onSegmentsValidationErrorResponse?: OnValidationErrorResponse`
-
-Callback triggered when dynamic segments validations returned issues. By default it returns a simple `400` response and issues are logged into the console.
+### Layout Server Components
 
 ```tsx
 import { z } from 'zod'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
+import { createSafeLayoutServerComponent } from '@sugardarius/anzen/server-components'
+import { auth } from '~/lib/auth'
+import { notFound, unauthorized } from 'next/navigation'
 
-export const GET = createSafeRouteHandler(
+export default createSafeLayoutServerComponent(
   {
     segments: {
       accountId: z.string(),
-      projectId: z.string().optional(),
-    },
-    onSegmentsValidationErrorResponse: (issues) => {
-      return Response.json({ issues }, { status: 400 })
-    },
-  },
-  async ({ segments }) => {
-    return Response.json({ segments })
-  }
-)
-```
-
-#### `searchParams?: TSearchParams`
-
-Search params used in the route.
-
-Please note the expected input is a `StandardSchemaDictionary`.
-
-```tsx
-import { string, numeric, optional } from 'decoders'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const GET = createSafeRouteHandler(
-  {
-    searchParams: {
-      query: string,
-      page: optional(numeric),
     },
-  },
-  async ({ searchParams }) => {
-    return Response.json({ searchParams })
-  }
-)
-```
-
-#### `onSearchParamsValidationErrorResponse?: OnValidationErrorResponse`
-
-Callback triggered when search params validations returned issues. By default it returns a simple `400` response and issues are logged into the console.
+    authorize: async ({ segments }) => {
+      const session = await auth.getSession()
+      if (!session) {
+        unauthorized()
+      }
 
-```tsx
-import { string, numeric, optional } from 'decoders'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
+      const hasAccess = await checkAccountAccess(
+        session.user.id,
+        segments.accountId
+      )
+      if (!hasAccess) {
+        notFound()
+      }
 
-export const GET = createSafeRouteHandler(
-  {
-    searchParams: {
-      query: string,
-      page: optional(numeric),
-    },
-    onSearchParamsValidationErrorResponse: (issues) => {
-      return Response.json({ issues }, { status: 400 })
+      return { user: session.user }
     },
   },
-  async ({ searchParams }) => {
-    return Response.json({ searchParams })
-  }
-)
-```
-
-#### `body?: TBody`
-
-Request body.
-
-Returns a `405` response if the request method is not `POST`, `PUT` or `PATCH`.
-
-Returns a `415`response if the request does not explicitly set the `Content-Type` to `application/json`.
-
-Please note the body is parsed as JSON, so it must be a valid JSON object. Body shouldn't be used with `formData` at the same time. They are **exclusive**.
-
-Why making the distinction? `formData` is used as a `StandardSchemaDictionary` whereas `body` is used as a `StandardSchemaV1`.
-
-```tsx
-import { z } from 'zod'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const POST = createSafeRouteHandler(
-  {
-    body: z.object({
-      name: z.string(),
-      model: z.string(),
-      apiKey: z.string(),
-    }),
-  },
-  async ({ body }) => {
-    return Response.json({ body })
+  async ({ auth, segments, children }) => {
+    return (
+      <div>
+        <header>Account: {segments.accountId}</header>
+        {children}
+      </div>
+    )
   }
 )
 ```
 
-> When validating the body the request is cloned to let you consume the body in the original request (e.g second arguments of handler function).
-
-#### `onBodyValidationErrorResponse?: OnValidationErrorResponse`
+## Framework validation agnostic
 
-Callback triggered when body validation returned issues. By default it returns a simple `400` response and issues are logged into the console.
+By design the factories are framework validation agnostic 🌟. When doing your validations you can use whatever you want as framework validation as long as it implements the [Standard Schema](https://standardschema.dev/) common interface. You can use your favorite validation library like [Zod](https://zod.dev/), [Validbot](https://valibot.dev/) or [decoders](https://decoders.cc/).
 
 ```tsx
+// Route handler example
 import { z } from 'zod'
+import { object, string, number } from 'decoders'
 import { createSafeRouteHandler } from '@sugardarius/anzen'
 
 export const POST = createSafeRouteHandler(
   {
-    body: z.object({
-      name: z.string(),
-      model: z.string(),
-      apiKey: z.string(),
+    // `zod` for segments dictionary validation
+    segments: { id: z.string() },
+    // `decoders` for body object validation
+    body: object({
+      id: number,
+      name: string,
     }),
-    onBodyValidationErrorResponse: (issues) => {
-      return Response.json({ issues }, { status: 400 })
-    },
   },
-  async ({ body }) => {
-    return Response.json({ body })
+  async ({ segments, body }) => {
+    return Response.json({ segments, body })
   }
 )
 ```
 
-#### `formData?: TFormData`
-
-Request form data.
-
-Returns a `405` response if the request method is not `POST`, `PUT` or `PATCH`.
-
-Returns a `415`response if the request does not explicitly set the `Content-Type` to `multipart/form-data` or to `application/x-www-form-urlencoded`.
-
-Please note formData shouldn't be used with `body` at the same time. They are **exclusive**.
-
-Why making the distinction? `formData` is used as a `StandardSchemaDictionary` whereas `body` is used as a `StandardSchemaV1`.
-
 ```tsx
+// Page server component example
 import { z } from 'zod'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
+import { string, number } from 'decoders'
+import { createSafePageServerComponent } from '@sugardarius/anzen/server-components'
 
-export const POST = createSafeRouteHandler(
+export default createSafePageServerComponent(
   {
-    formData: {
-      id: z.string(),
-      message: z.string(),
+    // `zod` for segments dictionary validation
+    segments: { id: z.string() },
+    // `decoders` for search params dictionary validation
+    searchParams: {
+      page: number,
     },
   },
-  async ({ formData }) => {
-    return Response.json({ formData })
+  async ({ segments, searchParams }) => {
+    return (
+      <div>
+        Race {segments.id} - Page {searchParams.page}
+      </div>
+    )
   }
 )
 ```
 
-> When validating the form data the request is cloned to let you consume the form data in the original request (e.g second arguments of handler function).
-
-#### `onFormDataValidationErrorResponse?: OnValidationErrorResponse`
-
-Callback triggered when form data validation returned issues. By default it returns a simple `400` response and issues are logged into the console.
-
-```tsx
-import { z } from 'zod'
-import { createSafeRouteHandler } from '@sugardarius/anzen'
+## Synchronous validations
 
-export const POST = createSafeRouteHandler(
-  {
-    formData: {
-      id: z.string(),
-      message: z.string(),
-    },
-    onFormDataValidationErrorResponse: (issues) => {
-      return Response.json({ issues }, { status: 400 })
-    },
-  },
-  async ({ formData }) => {
-    return Response.json({ formData })
-  }
-)
-```
+The factories do not support async validations. As required by the [Standard Schema](https://standardschema.dev/) common interface we should avoid it. In the context of route handlers and server components it's not necessary.
 
-### Error handling
+If you define an async validation then the factory will throw an error.
 
-By design the factory will catch any error thrown in the route handler will return a simple response with `500` status.
+## Fair use note
 
-You can customize the error response if you want to fine tune error response management.
+Please note that if you're not using any of the proposed options in the factories it means you're surely don't need them.
 
 ```tsx
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-import { HttpError, DbUnknownError } from '~/lib/errors'
-import { db } from '~/lib/db'
-
-export const GET = createSafeRouteHandler(
-  {
-    onErrorResponse: async (err: unknown): Promise<Response> => {
-      if (err instanceof HttpError) {
-        return new Response(err.message, { status: err.status })
-      } else if (err instanceof DbUnknownError) {
-        return new Response(err.message, { status: err.status })
-      }
-
-      return new Response('Internal server error', { status: 500 })
-    },
-  },
-  async (): Promise<Response> => {
-    const [data, err] = await db.findUnique({ id: 'liveblocks' })
-
-    if (err) {
-      throw new DbUnknownError(err.message, 500)
-    }
-
-    if (data === null) {
-      throw new HttpError(404)
-    }
+// Route handler
+// Calling 👇🏻
+export const GET = createSafeRouteHandler({}, async () => {
+  return new Response(null, { status: 200 })
+})
 
-    return Response.json({ data })
-  }
-)
+// is equal to declare the route handler this way 👇🏻
+export function GET() {
+  return new Response(null, { status: 200 })
+}
+// except `createSafeRouteHandler` will provide by default a native error catching
+// and will return a `500` response. That's the only advantage.
 ```
 
-### Using the request in the route handler
-
-The original `request` is cascaded in the route handler function if you need to access to it.
-
 ```tsx
-import { createSafeRouteHandler } from '@sugardarius/anzen'
-
-export const GET = createSafeRouteHandler({}, async (ctx, req) => {
-  console.log('integrity', req.integrity)
-  return new Response(null, { status: 200 })
+// Page server component
+// Calling 👇🏻
+export default createSafePageServerComponent({}, async () => {
+  return <div>Hello</div>
 })
-```
 
-## Fair use note
-
-Please note that if you're not using any of the proposed options in `createSafeRouteHandler` it means you're surely don't need it.
+// is equal to declare the page server component this way 👇🏻
+export default async function Page() {
+  return <div>Hello</div>
+}
+```
 
 ```tsx
+// Layout server component
 // Calling 👇🏻
-export const GET = createSafeRouteHandler({}, async () => {
-  return new Response(null, { status: 200 })
+export default createSafeLayoutServerComponent({}, async ({ children }) => {
+  return <div>{children}</div>
 })
 
-// is equal to declare the route handler this way 👇🏻
-export function GET() {
-  return new Response(null, { status: 200 })
+// is equal to declare the layout server component this way 👇🏻
+export default async function Layout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return <div>{children}</div>
 }
-// excepts `createSafeRouteHandler` will provide by default a native error catching
-// and will return a `500` response. That's the only advantage.
 ```
 
-Feel free to open an issue or a PR if you think a relevant option could be added into the factory 🙂
+Feel free to open an issue or a PR if you think a relevant option could be added into the factories 🙂
 
 ## Requirements
 
-The factory `createSafeRouteHandler` requires Next.js `v14` or `v15` and typescript `v5` as peer dependencies.
+The factories require Next.js `v14`, `v15` or `v16` and typescript `v5` as peer dependencies.
 
 ## Contributing
 

package/dist/chunk-DT3TEL5X.js

@@ -0,0 +1,2 @@
+function i(e){return e!==null&&(typeof e=="object"||typeof e=="function")&&typeof e.then=="function"}function u(e,t){if(i(e))throw new Error(t)}function p(e=!1){let t=e||process.env.NODE_ENV!=="production";return{info:(r,...n)=>{t&&console.log(r,...n)},error:(r,...n)=>{t&&console.error(r,...n)},warn:(r,...n)=>{t&&console.warn(r,...n)}}}function c(){let e=null,t=null;return{start:()=>{e=performance.now()},stop:()=>{if(e===null)throw new Error("Execution clock was not started.");t=performance.now()},get:()=>{if(!e||!t)throw new Error("Execution clock has not been started or stopped.");return`${(t-e).toFixed(2)}ms`}}}function m(e,t,r="Validation must be synchronous but schema returned a Promise."){let n=e["~standard"].validate(t);return u(n,r),n}var d=(e,t)=>t in e;function S(e,t){let r={},n=[];for(let o in e){if(!d(e,o))continue;let a=e[o]["~standard"].validate(t[o]);if(u(a,`Validation must be synchronous, but ${o} returned a Promise.`),a.issues){n.push(...a.issues.map(s=>({...s,path:[o,...s.path??[]]})));continue}r[o]=a.value}return n.length>0?{issues:n}:{value:r}}export{p as a,c as b,m as c,S as d};
+//# sourceMappingURL=chunk-DT3TEL5X.js.map

package/dist/chunk-DT3TEL5X.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts","../src/standard-schema.ts"],"sourcesContent":["export function isPromise<T>(\n  value: unknown\n): value is Promise<T> | PromiseLike<T> {\n  return (\n    value !== null &&\n    (typeof value === 'object' || typeof value === 'function') &&\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    typeof (value as any).then === 'function'\n  )\n}\n\nexport function assertsSyncOperation<T>(\n  value: T | Promise<T> | PromiseLike<T>,\n  message: string\n): asserts value is T {\n  if (isPromise<T>(value)) {\n    throw new Error(message)\n  }\n}\n\nexport function createLogger(debug: boolean = false) {\n  const shouldLog = debug || process.env.NODE_ENV !== 'production'\n  return {\n    info: (message: string, ...rest: unknown[]): void => {\n      if (shouldLog) {\n        console.log(message, ...rest)\n      }\n    },\n    error: (message: string, ...rest: unknown[]): void => {\n      if (shouldLog) {\n        console.error(message, ...rest)\n      }\n    },\n    warn: (message: string, ...rest: unknown[]): void => {\n      if (shouldLog) {\n        console.warn(message, ...rest)\n      }\n    },\n  }\n}\n\nexport function createExecutionClock() {\n  let startTime: number | null = null\n  let endTime: number | null = null\n\n  return {\n    start: (): void => {\n      startTime = performance.now()\n    },\n    stop: (): void => {\n      if (startTime === null) {\n        throw new Error('Execution clock was not started.')\n      }\n      endTime = performance.now()\n    },\n    get: (): string => {\n      if (!startTime || !endTime) {\n        throw new Error('Execution clock has not been started or stopped.')\n      }\n\n      const duration = endTime - startTime\n      return `${duration.toFixed(2)}ms`\n    },\n  }\n}\n","import { assertsSyncOperation } from './utils'\n\n/** The Standard Schema interface. */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n  /** The Standard Schema properties. */\n  readonly '~standard': StandardSchemaV1.Props<Input, Output>\n}\n\nexport declare namespace StandardSchemaV1 {\n  /** The Standard Schema properties interface. */\n  export interface Props<Input = unknown, Output = Input> {\n    /** The version number of the standard. */\n    readonly version: 1\n    /** The vendor name of the schema library. */\n    readonly vendor: string\n    /** Validates unknown input values. */\n    readonly validate: (\n      value: unknown\n    ) => Result<Output> | Promise<Result<Output>>\n    /** Inferred types associated with the schema. */\n    readonly types?: Types<Input, Output> | undefined\n  }\n\n  /** The result interface of the validate function. */\n  export type Result<Output> = SuccessResult<Output> | FailureResult\n\n  /** The result interface if validation succeeds. */\n  export interface SuccessResult<Output> {\n    /** The typed output value. */\n    readonly value: Output\n    /** The non-existent issues. */\n    readonly issues?: undefined\n  }\n\n  /** The result interface if validation fails. */\n  export interface FailureResult {\n    /** The issues of failed validation. */\n    readonly issues: ReadonlyArray<Issue>\n  }\n\n  /** The issue interface of the failure output. */\n  export interface Issue {\n    /** The error message of the issue. */\n    readonly message: string\n    /** The path of the issue, if any. */\n    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined\n  }\n\n  /** The path segment interface of the issue. */\n  export interface PathSegment {\n    /** The key representing a path segment. */\n    readonly key: PropertyKey\n  }\n\n  /** The Standard Schema types interface. */\n  export interface Types<Input = unknown, Output = Input> {\n    /** The input type of the schema. */\n    readonly input: Input\n    /** The output type of the schema. */\n    readonly output: Output\n  }\n\n  /** Infers the input type of a Standard Schema. */\n  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<\n    Schema['~standard']['types']\n  >['input']\n\n  /** Infers the output type of a Standard Schema. */\n  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<\n    Schema['~standard']['types']\n  >['output']\n}\n\nexport function validateWithSchema<TSchema extends StandardSchemaV1>(\n  schema: TSchema,\n  value: unknown,\n  errSyncMsg = 'Validation must be synchronous but schema returned a Promise.'\n): StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>> {\n  const result = schema['~standard'].validate(value)\n  assertsSyncOperation(result, errSyncMsg)\n\n  return result\n}\n\n// Thanks to `@t3-env/core` (👉🏻 https://github.com/t3-oss/t3-env/blob/main/packages/core/src/standard.ts)\n// for this awesome dictionary schema.\nexport type StandardSchemaDictionary<\n  Input = Record<string, unknown>,\n  Output extends Record<keyof Input, unknown> = Input,\n> = {\n  [K in keyof Input]-?: StandardSchemaV1<Input[K], Output[K]>\n}\n\nexport namespace StandardSchemaDictionary {\n  export type InferInput<T extends StandardSchemaDictionary> = {\n    [K in keyof T]: StandardSchemaV1.InferInput<T[K]>\n  }\n  export type InferOutput<T extends StandardSchemaDictionary> = {\n    [K in keyof T]: StandardSchemaV1.InferOutput<T[K]>\n  }\n}\n\nconst hasDictKey = <T extends object, K extends PropertyKey>(\n  obj: T,\n  key: K\n): obj is T & Record<typeof key, unknown> => {\n  return key in obj\n}\n\nexport function parseWithDictionary<TDict extends StandardSchemaDictionary>(\n  dictionary: TDict,\n  value: Record<string, unknown>\n): StandardSchemaV1.Result<StandardSchemaDictionary.InferOutput<TDict>> {\n  const result: Record<string, unknown> = {}\n  const issues: StandardSchemaV1.Issue[] = []\n\n  for (const key in dictionary) {\n    if (!hasDictKey(dictionary, key)) {\n      continue\n    }\n    // NOTE: safe to assert as we're ensuring just before key isn't undefined\n    const propResult = dictionary[key]!['~standard'].validate(value[key])\n\n    assertsSyncOperation(\n      propResult,\n      `Validation must be synchronous, but ${key} returned a Promise.`\n    )\n\n    if (propResult.issues) {\n      issues.push(\n        ...propResult.issues.map((issue) => ({\n          ...issue,\n          path: [key, ...(issue.path ?? [])],\n        }))\n      )\n      continue\n    }\n    result[key] = propResult.value\n  }\n\n  if (issues.length > 0) {\n    return { issues }\n  }\n\n  return { value: result as never }\n}\n"],"mappings":"AAAO,SAASA,EACdC,EACsC,CACtC,OACEA,IAAU,OACT,OAAOA,GAAU,UAAY,OAAOA,GAAU,aAE/C,OAAQA,EAAc,MAAS,UAEnC,CAEO,SAASC,EACdD,EACAE,EACoB,CACpB,GAAIH,EAAaC,CAAK,EACpB,MAAM,IAAI,MAAME,CAAO,CAE3B,CAEO,SAASC,EAAaC,EAAiB,GAAO,CACnD,IAAMC,EAAYD,GAAS,QAAQ,IAAI,WAAa,aACpD,MAAO,CACL,KAAM,CAACF,KAAoBI,IAA0B,CAC/CD,GACF,QAAQ,IAAIH,EAAS,GAAGI,CAAI,CAEhC,EACA,MAAO,CAACJ,KAAoBI,IAA0B,CAChDD,GACF,QAAQ,MAAMH,EAAS,GAAGI,CAAI,CAElC,EACA,KAAM,CAACJ,KAAoBI,IAA0B,CAC/CD,GACF,QAAQ,KAAKH,EAAS,GAAGI,CAAI,CAEjC,CACF,CACF,CAEO,SAASC,GAAuB,CACrC,IAAIC,EAA2B,KAC3BC,EAAyB,KAE7B,MAAO,CACL,MAAO,IAAY,CACjBD,EAAY,YAAY,IAAI,CAC9B,EACA,KAAM,IAAY,CAChB,GAAIA,IAAc,KAChB,MAAM,IAAI,MAAM,kCAAkC,EAEpDC,EAAU,YAAY,IAAI,CAC5B,EACA,IAAK,IAAc,CACjB,GAAI,CAACD,GAAa,CAACC,EACjB,MAAM,IAAI,MAAM,kDAAkD,EAIpE,MAAO,IADUA,EAAUD,GACR,QAAQ,CAAC,CAAC,IAC/B,CACF,CACF,CCSO,SAASE,EACdC,EACAC,EACAC,EAAa,gEACmD,CAChE,IAAMC,EAASH,EAAO,WAAW,EAAE,SAASC,CAAK,EACjD,OAAAG,EAAqBD,EAAQD,CAAU,EAEhCC,CACT,CAoBA,IAAME,EAAa,CACjBC,EACAC,IAEOA,KAAOD,EAGT,SAASE,EACdC,EACAR,EACsE,CACtE,IAAME,EAAkC,CAAC,EACnCO,EAAmC,CAAC,EAE1C,QAAWH,KAAOE,EAAY,CAC5B,GAAI,CAACJ,EAAWI,EAAYF,CAAG,EAC7B,SAGF,IAAMI,EAAaF,EAAWF,CAAG,EAAG,WAAW,EAAE,SAASN,EAAMM,CAAG,CAAC,EAOpE,GALAH,EACEO,EACA,uCAAuCJ,CAAG,sBAC5C,EAEII,EAAW,OAAQ,CACrBD,EAAO,KACL,GAAGC,EAAW,OAAO,IAAKC,IAAW,CACnC,GAAGA,EACH,KAAM,CAACL,EAAK,GAAIK,EAAM,MAAQ,CAAC,CAAE,CACnC,EAAE,CACJ,EACA,QACF,CACAT,EAAOI,CAAG,EAAII,EAAW,KAC3B,CAEA,OAAID,EAAO,OAAS,EACX,CAAE,OAAAA,CAAO,EAGX,CAAE,MAAOP,CAAgB,CAClC","names":["isPromise","value","assertsSyncOperation","message","createLogger","debug","shouldLog","rest","createExecutionClock","startTime","endTime","validateWithSchema","schema","value","errSyncMsg","result","assertsSyncOperation","hasDictKey","obj","key","parseWithDictionary","dictionary","issues","propResult","issue"]}

package/dist/chunk-UDCVGQMH.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function i(e){return e!==null&&(typeof e=="object"||typeof e=="function")&&typeof e.then=="function"}function u(e,t){if(i(e))throw new Error(t)}function p(e=!1){let t=e||process.env.NODE_ENV!=="production";return{info:(r,...n)=>{t&&console.log(r,...n)},error:(r,...n)=>{t&&console.error(r,...n)},warn:(r,...n)=>{t&&console.warn(r,...n)}}}function c(){let e=null,t=null;return{start:()=>{e=performance.now()},stop:()=>{if(e===null)throw new Error("Execution clock was not started.");t=performance.now()},get:()=>{if(!e||!t)throw new Error("Execution clock has not been started or stopped.");return`${(t-e).toFixed(2)}ms`}}}function m(e,t,r="Validation must be synchronous but schema returned a Promise."){let n=e["~standard"].validate(t);return u(n,r),n}var d=(e,t)=>t in e;function S(e,t){let r={},n=[];for(let o in e){if(!d(e,o))continue;let a=e[o]["~standard"].validate(t[o]);if(u(a,`Validation must be synchronous, but ${o} returned a Promise.`),a.issues){n.push(...a.issues.map(s=>({...s,path:[o,..._nullishCoalesce(s.path, () => ([]))]})));continue}r[o]=a.value}return n.length>0?{issues:n}:{value:r}}exports.a = p; exports.b = c; exports.c = m; exports.d = S;
+//# sourceMappingURL=chunk-UDCVGQMH.cjs.map

package/dist/chunk-UDCVGQMH.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"names":["isPromise","value","assertsSyncOperation","message","createLogger","debug","shouldLog","rest","createExecutionClock","startTime","endTime"],"mappings":"AAAO,sLAASA,CAAAA,CACdC,CAAAA,CACsC,CACtC,OACEA,CAAAA,GAAU,IAAA,EAAA,CACT,OAAOA,CAAAA,EAAU,QAAA,EAAY,OAAOA,CAAAA,EAAU,UAAA,CAAA,EAE/C,OAAQA,CAAAA,CAAc,IAAA,EAAS,UAEnC,CAEO,SAASC,CAAAA,CACdD,CAAAA,CACAE,CAAAA,CACoB,CACpB,EAAA,CAAIH,CAAAA,CAAaC,CAAK,CAAA,CACpB,MAAM,IAAI,KAAA,CAAME,CAAO,CAE3B,CAEO,SAASC,CAAAA,CAAaC,CAAAA,CAAiB,CAAA,CAAA,CAAO,CACnD,IAAMC,CAAAA,CAAYD,CAAAA,EAAS,OAAA,CAAQ,GAAA,CAAI,QAAA,GAAa,YAAA,CACpD,MAAO,CACL,IAAA,CAAM,CAACF,CAAAA,CAAAA,GAAoBI,CAAAA,CAAAA,EAA0B,CAC/CD,CAAAA,EACF,OAAA,CAAQ,GAAA,CAAIH,CAAAA,CAAS,GAAGI,CAAI,CAEhC,CAAA,CACA,KAAA,CAAO,CAACJ,CAAAA,CAAAA,GAAoBI,CAAAA,CAAAA,EAA0B,CAChDD,CAAAA,EACF,OAAA,CAAQ,KAAA,CAAMH,CAAAA,CAAS,GAAGI,CAAI,CAElC,CAAA,CACA,IAAA,CAAM,CAACJ,CAAAA,CAAAA,GAAoBI,CAAAA,CAAAA,EAA0B,CAC/CD,CAAAA,EACF,OAAA,CAAQ,IAAA,CAAKH,CAAAA,CAAS,GAAGI,CAAI,CAEjC,CACF,CACF,CAEO,SAASC,CAAAA,CAAAA,CAAuB,CACrC,IAAIC,CAAAA,CAA2B,IAAA,CAC3BC,CAAAA,CAAyB,IAAA,CAE7B,MAAO,CACL,KAAA,CAAO,CAAA,CAAA,EAAY,CACjBD,CAAAA,CAAY,WAAA,CAAY,GAAA,CAAI,CAC9B,CAAA,CACA,IAAA,CAAM,CAAA,CAAA,EAAY,CAChB,EAAA,CAAIA,CAAAA,GAAc,IAAA,CAChB,MAAM,IAAI,KAAA,CAAM,kCAAkC,CAAA,CAEpDC,CAAAA,CAAU,WAAA,CAAY,GAAA,CAAI,CAC5B,CAAA,CACA,GAAA,CAAK,CAAA,CAAA,EAAc,CACjB,EAAA,CAAI,CAACD,CAAAA,EAAa,CAACC,CAAAA,CACjB,MAAM,IAAI,KAAA,CAAM,kDAAkD,CAAA,CAIpE,MAAO,CAAA,EAAA","file":"/home/runner/work/anzen/anzen/dist/chunk-UDCVGQMH.cjs","sourcesContent":["export function isPromise<T>(\n  value: unknown\n): value is Promise<T> | PromiseLike<T> {\n  return (\n    value !== null &&\n    (typeof value === 'object' || typeof value === 'function') &&\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    typeof (value as any).then === 'function'\n  )\n}\n\nexport function assertsSyncOperation<T>(\n  value: T | Promise<T> | PromiseLike<T>,\n  message: string\n): asserts value is T {\n  if (isPromise<T>(value)) {\n    throw new Error(message)\n  }\n}\n\nexport function createLogger(debug: boolean = false) {\n  const shouldLog = debug || process.env.NODE_ENV !== 'production'\n  return {\n    info: (message: string, ...rest: unknown[]): void => {\n      if (shouldLog) {\n        console.log(message, ...rest)\n      }\n    },\n    error: (message: string, ...rest: unknown[]): void => {\n      if (shouldLog) {\n        console.error(message, ...rest)\n      }\n    },\n    warn: (message: string, ...rest: unknown[]): void => {\n      if (shouldLog) {\n        console.warn(message, ...rest)\n      }\n    },\n  }\n}\n\nexport function createExecutionClock() {\n  let startTime: number | null = null\n  let endTime: number | null = null\n\n  return {\n    start: (): void => {\n      startTime = performance.now()\n    },\n    stop: (): void => {\n      if (startTime === null) {\n        throw new Error('Execution clock was not started.')\n      }\n      endTime = performance.now()\n    },\n    get: (): string => {\n      if (!startTime || !endTime) {\n        throw new Error('Execution clock has not been started or stopped.')\n      }\n\n      const duration = endTime - startTime\n      return `${duration.toFixed(2)}ms`\n    },\n  }\n}\n"]}