@nifrajs/schema 0.1.0-alpha.1

package/src/t.ts

@@ -0,0 +1,70 @@
+import {
+  type ArrayOptions,
+  type IntegerOptions,
+  type NumberOptions,
+  type ObjectOptions,
+  type StringOptions,
+  type TLiteralValue,
+  type TSchema,
+  type TUnion,
+  Type,
+} from "@sinclair/typebox"
+import { fromTypeBox, type NifraSchema } from "./adapter.ts"
+
+type Props = Record<string, NifraSchema>
+
+/** Pull each property's raw TypeBox schema out of its `NifraSchema` wrapper. */
+function unwrap<P extends Props>(props: P): { [K in keyof P]: P[K]["jsonSchema"] } {
+  const out: Record<string, TSchema> = {}
+  // Object.entries → own enumerable string keys only (no prototype walk).
+  for (const [key, schema] of Object.entries(props)) out[key] = schema.jsonSchema
+  return out as { [K in keyof P]: P[K]["jsonSchema"] }
+}
+
+/**
+ * The built-in schema builder. Each constructor returns a `NifraSchema` — a
+ * Standard Schema whose validated output type flows into `c.body`/`c.query`, and
+ * whose `jsonSchema` powers `toOpenAPI`. Options (min/max, length, pattern, …)
+ * pass straight through to TypeBox and so become JSON Schema constraints.
+ *
+ * Composite constructors are generic over the *inner* TypeBox schema `T extends
+ * TSchema` (not over `NifraSchema`): reading `.jsonSchema` off a value typed only as
+ * `NifraSchema` would erase to the `TSchema` constraint and collapse the output type
+ * to `unknown`. Capturing `T` keeps `Static<T>` precise (`string[]`, not
+ * `unknown[]`).
+ */
+export const t = {
+  string: (options?: StringOptions) => fromTypeBox(Type.String(options)),
+  number: (options?: NumberOptions) => fromTypeBox(Type.Number(options)),
+  integer: (options?: IntegerOptions) => fromTypeBox(Type.Integer(options)),
+  boolean: () => fromTypeBox(Type.Boolean()),
+  null: () => fromTypeBox(Type.Null()),
+  literal: <const L extends TLiteralValue>(value: L) => fromTypeBox(Type.Literal(value)),
+
+  // `t.object` REJECTS unknown fields by default (`additionalProperties: false`) — the trust-boundary
+  // rule. A body with extra keys fails validation (a 400), so `c.body` never carries attacker-supplied
+  // properties (no mass-assignment). Use `t.looseObject` (or pass `{ additionalProperties: true }`) to
+  // opt into an open object; an explicit `options.additionalProperties` always wins over the default.
+  object: <P extends Props>(props: P, options?: ObjectOptions) =>
+    fromTypeBox(Type.Object(unwrap(props), { additionalProperties: false, ...options })),
+  /** Like `t.object` but ACCEPTS (and passes through) unknown fields — the explicit opt-out of the
+   * strict default. Prefer `t.object` unless you genuinely need an open object. */
+  looseObject: <P extends Props>(props: P, options?: ObjectOptions) =>
+    fromTypeBox(Type.Object(unwrap(props), { additionalProperties: true, ...options })),
+  array: <T extends TSchema>(item: NifraSchema<T>, options?: ArrayOptions) =>
+    fromTypeBox(Type.Array(item.jsonSchema, options)),
+  /** Marks a property optional inside `t.object`; standalone it is `T | undefined`. */
+  optional: <T extends TSchema>(schema: NifraSchema<T>) =>
+    fromTypeBox(Type.Optional(schema.jsonSchema)),
+  // `const S` captures the argument as a tuple; the explicit return type then maps
+  // over that captured tuple (`S[K]["jsonSchema"]`) so the union's `Static` is
+  // `A | B`, not `unknown` — the value-level `.map` can't preserve per-element
+  // types, so the output type is derived from `S` and the result cast to match
+  // (order/length are preserved by `map`, so the tuple shape is sound).
+  union: <const S extends readonly NifraSchema[]>(schemas: S) =>
+    fromTypeBox(
+      Type.Union((schemas as readonly NifraSchema[]).map((schema) => schema.jsonSchema)),
+    ) as NifraSchema<TUnion<{ -readonly [K in keyof S]: S[K]["jsonSchema"] }>>,
+  record: <T extends TSchema>(value: NifraSchema<T>, options?: ObjectOptions) =>
+    fromTypeBox(Type.Record(Type.String(), value.jsonSchema, options)),
+} as const