effect-qb 0.17.0 → 0.19.0

package/src/postgres/internal/renderer.ts

@@ -1,9 +1,10 @@
 import * as Query from "../../internal/query.js"
 import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
 import { type RenderState } from "../../internal/dialect.js"
 import { postgresDialect } from "./dialect.js"
 import { type Projection } from "../../internal/projections.js"
-import { renderQueryAst } from "./sql-expression-renderer.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
 
 /**
  * Minimal rendered-query payload produced by the built-in Postgres renderer.
@@ -20,6 +21,7 @@ export interface PostgresRenderResult {
 
 export interface PostgresRenderOptions {
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
 }
 
 /**
@@ -32,9 +34,11 @@ export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
   const state: RenderState = {
     params: [],
     valueMappings: options.valueMappings,
+    casing: options.casing,
     ctes: [],
     cteNames: new Set<string>(),
-    cteSources: new Map<string, unknown>()
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
   }
   const rendered = renderQueryAst(
     Query.getAst(plan as Query.Plan.Any) as any,

package/src/postgres/internal/schema-ddl.ts

@@ -1,7 +1,7 @@
 import type * as Expression from "../../internal/scalar.js"
 import type { RenderState, SqlDialect } from "../../internal/dialect.js"
 import * as SchemaExpression from "../../internal/schema-expression.js"
-import { renderExpression } from "./sql-expression-renderer.js"
+import { renderExpression } from "../../internal/sql-expression-renderer.js"
 import type { DdlExpressionLike } from "../../internal/table-options.js"
 import { parse, toSql } from "pgsql-ast-parser"
 import { postgresDialect } from "./dialect.js"
@@ -30,21 +30,30 @@ const inlineLiteralDialect: SqlDialect<"postgres"> = {
       return String(value)
     }
     if (value instanceof Date) {
+      if (Number.isNaN(value.getTime())) {
+        throw new Error("Expected a valid Date value")
+      }
       return escapeString(value.toISOString())
     }
     return escapeString(String(value))
   }
 }
 
-export const renderDdlExpressionSql = (expression: DdlExpressionLike): string =>
+const makeExpressionState = (state: Partial<RenderState> = {}): RenderState => ({
+  ...state,
+  params: [],
+  ctes: [],
+  cteNames: new Set(),
+  cteSources: new Map()
+})
+
+export const renderDdlExpressionSql = (
+  expression: DdlExpressionLike,
+  state?: Partial<RenderState>
+): string =>
   SchemaExpression.isSchemaExpression(expression)
     ? SchemaExpression.render(expression)
-    : renderExpression(expression as Expression.Any, {
-        params: [],
-        ctes: [],
-        cteNames: new Set(),
-        cteSources: new Map()
-      }, inlineLiteralDialect)
+    : renderExpression(expression as Expression.Any, makeExpressionState(state), inlineLiteralDialect)
 
 const stripRedundantOuterParens = (value: string): string => {
   let current = value.trim()
@@ -99,8 +108,11 @@ const canonicalizeDdlExpressionSql = (value: string): string =>
       )
   )
 
-export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
-  const rendered = renderDdlExpressionSql(expression)
+export const normalizeDdlExpressionSql = (
+  expression: DdlExpressionLike,
+  state?: Partial<RenderState>
+): string => {
+  const rendered = renderDdlExpressionSql(expression, state)
   try {
     return canonicalizeDdlExpressionSql(toSql.expr(parse(rendered, "expr")))
   } catch {

package/src/postgres/internal/schema-model.ts

@@ -1,7 +1,11 @@
 import * as Table from "../../internal/table.js"
 import type { AnyColumnDefinition } from "../../internal/column-state.js"
+import type { RenderState } from "../../internal/dialect.js"
+import * as Casing from "../../internal/casing.js"
+import * as Expression from "../../internal/scalar.js"
+import * as SchemaExpression from "../../internal/schema-expression.js"
 import { normalizeDdlExpressionSql } from "./schema-ddl.js"
-import type { TableOptionSpec } from "../../internal/table-options.js"
+import { validateOptions, type ColumnList, type DdlExpressionLike, type IndexKeySpec, type TableOptionSpec } from "../../internal/table-options.js"
 import type { EnumDefinition } from "../schema-management.js"
 import { EnumTypeId } from "../schema-management.js"
 
@@ -52,15 +56,238 @@ export const isTableDefinition = (value: unknown): value is Table.AnyTable =>
 export const isEnumDefinition = (value: unknown): value is EnumDefinition =>
   typeof value === "object" && value !== null && EnumTypeId in value
 
+const applyCasing = (
+  casing: Casing.Options | undefined,
+  category: Casing.Category,
+  name: string
+): string =>
+  Casing.applyCategory(casing, category, name)
+
+const mapColumnList = (
+  columns: ColumnList,
+  casing: Casing.Options | undefined
+): ColumnList =>
+  !Array.isArray(columns)
+    ? columns
+    : columns.length === 0
+      ? columns
+      : [
+          mapCasedValue(columns[0], casing, "columns"),
+          ...columns.slice(1).map((column) => mapCasedValue(column, casing, "columns"))
+        ] as ColumnList
+
+const expressionStateForTable = (
+  state: Table.AnyTable[typeof Table.TypeId],
+  tableName: string,
+  columns: ReadonlyMap<string, string>,
+  casing: Casing.Options | undefined
+): Partial<RenderState> => ({
+  casing,
+  rowLocalColumns: true,
+  sourceNames: new Map([
+    [state.name, { tableName, columns }],
+    [state.baseName, { tableName, columns }]
+  ])
+})
+
+const mapDdlExpression = (
+  expression: DdlExpressionLike,
+  state: Partial<RenderState>
+): SchemaExpression.SchemaExpression =>
+  SchemaExpression.fromSql(normalizeDdlExpressionSql(expression, state))
+
+function mapOptionName(
+  name: string,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): string
+function mapOptionName(
+  name: unknown,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): unknown
+function mapOptionName(
+  name: unknown,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): unknown {
+  return typeof name === "string"
+    ? applyCasing(casing, category, name)
+    : name
+}
+
+function mapCasedValue(
+  value: string,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): string
+function mapCasedValue(
+  value: unknown,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): unknown
+function mapCasedValue(
+  value: unknown,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): unknown {
+  return typeof value === "string"
+    ? applyCasing(casing, category, value)
+    : value
+}
+
+const isDdlExpressionLike = (value: unknown): value is DdlExpressionLike =>
+  typeof value === "object" &&
+  value !== null &&
+  (Expression.TypeId in value || SchemaExpression.TypeId in value)
+
+function mapIndexKey(
+  key: IndexKeySpec,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): IndexKeySpec
+function mapIndexKey(
+  key: unknown,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): unknown
+function mapIndexKey(
+  key: unknown,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): unknown {
+  if (typeof key !== "object" || key === null || !("kind" in key)) {
+    return key
+  }
+  const kind = (key as { readonly kind?: unknown }).kind
+  if (kind === "column") {
+    const column = (key as { readonly column?: unknown }).column
+    return typeof column === "string"
+      ? {
+          ...key,
+          column: applyCasing(casing, "columns", column)
+        }
+      : key
+  }
+  if (kind === "expression") {
+    const expression = (key as { readonly expression?: unknown }).expression
+    return isDdlExpressionLike(expression)
+      ? {
+          ...key,
+          expression: mapDdlExpression(expression, expressionState)
+        }
+      : key
+  }
+  return key
+}
+
+const mapOption = (
+  option: TableOptionSpec,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): TableOptionSpec => {
+  switch (option.kind) {
+    case "index":
+      return {
+        ...option,
+        columns: option.columns === undefined ? undefined : mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "indexes"),
+        include: option.include === undefined
+          ? undefined
+          : Array.isArray(option.include)
+            ? option.include.map((column) => mapCasedValue(column, casing, "columns")) as unknown as readonly string[]
+            : option.include,
+        predicate: option.predicate === undefined
+          ? undefined
+          : isDdlExpressionLike(option.predicate)
+            ? mapDdlExpression(option.predicate, expressionState)
+            : option.predicate,
+        keys: option.keys === undefined
+          ? undefined
+          : Array.isArray(option.keys)
+            ? option.keys.length === 0
+              ? option.keys
+              : [
+                  mapIndexKey(option.keys[0], casing, expressionState),
+                  ...option.keys.slice(1).map((key) => mapIndexKey(key, casing, expressionState))
+                ] as unknown as readonly [IndexKeySpec, ...IndexKeySpec[]]
+            : option.keys
+      }
+    case "primaryKey":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints")
+      }
+    case "unique":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints")
+      }
+    case "foreignKey":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints"),
+        references: () => {
+          const reference = typeof option.references === "function"
+            ? option.references()
+            : option.references
+          if (typeof reference !== "object" || reference === null) {
+            return reference
+          }
+          const referenceCasing = reference.casing
+          return {
+            ...reference,
+            tableName: mapCasedValue(reference.tableName, referenceCasing, "tables"),
+            schemaName: reference.schemaName === undefined
+              ? undefined
+              : mapCasedValue(reference.schemaName, referenceCasing, "schemas"),
+            columns: mapColumnList(reference.columns, referenceCasing),
+            knownColumns: reference.knownColumns === undefined
+              ? undefined
+              : Array.isArray(reference.knownColumns)
+                ? reference.knownColumns.map((column) =>
+                  mapCasedValue(column, referenceCasing, "columns")) as unknown as readonly string[]
+                : reference.knownColumns
+          }
+        }
+      }
+    case "check":
+      return {
+        ...option,
+        name: mapOptionName(option.name, casing, "constraints"),
+        predicate: isDdlExpressionLike(option.predicate)
+          ? mapDdlExpression(option.predicate, expressionState)
+          : option.predicate
+      }
+    default:
+      return option
+  }
+}
+
 export const toTableModel = (table: Table.AnyTable): TableModel => {
   const state = table[Table.TypeId]
+  const casing = state.casing
+  const tableName = applyCasing(casing, "tables", state.baseName)
+  const schemaName = state.schemaName === undefined
+    ? undefined
+    : applyCasing(casing, "schemas", state.schemaName)
   const fields = state.fields as Record<string, AnyColumnDefinition>
+  const options = table[Table.OptionsSymbol] as unknown
+  const normalizedOptions = (Array.isArray(options) ? options : [options]) as readonly TableOptionSpec[]
+  validateOptions(state.name, fields, normalizedOptions)
+  const columnNames = new Map(
+    Object.keys(fields).map((name) => [name, applyCasing(casing, "columns", name)] as const)
+  )
+  const expressionState = expressionStateForTable(state, tableName, columnNames, casing)
   const columns = Object.entries(fields).map(([name, column]) => {
     const metadata = column.metadata
     const enumDefinition = metadata.enum
     const ddlType = metadata.ddlType ?? metadata.dbType.kind
     return {
-      name,
+      name: columnNames.get(name) ?? name,
       ddlType,
       dbTypeKind: enumDefinition?.name ?? column.metadata.dbType.kind,
       typeKind: enumDefinition === undefined ? undefined : "e",
@@ -70,20 +297,24 @@ export const toTableModel = (table: Table.AnyTable): TableModel => {
       generated: column.metadata.generated,
       defaultSql: column.metadata.defaultValue === undefined
         ? undefined
-        : normalizeDdlExpressionSql(column.metadata.defaultValue),
+        : normalizeDdlExpressionSql(column.metadata.defaultValue, expressionState),
       generatedSql: column.metadata.generatedValue === undefined
         ? undefined
-        : normalizeDdlExpressionSql(column.metadata.generatedValue),
+        : normalizeDdlExpressionSql(column.metadata.generatedValue, expressionState),
       identity: column.metadata.identity,
       column
     }
   }) satisfies ReadonlyArray<ColumnModel>
   return {
     kind: "table",
-    schemaName: state.schemaName,
-    name: state.baseName,
+    schemaName,
+    name: tableName,
     columns,
-    options: table[Table.OptionsSymbol],
+    options: normalizedOptions.map((option) =>
+      typeof option === "object" && option !== null && "kind" in option
+        ? mapOption(option, casing, expressionState)
+        : option as TableOptionSpec
+    ),
     table
   }
 }

package/src/postgres/json.ts

@@ -9,11 +9,12 @@ import type {
   JsonTextResult,
   JsonValueAtPath
 } from "../internal/json/types.js"
+import type { LiteralStringInput } from "../internal/table-options.js"
 import { json as postgresJson, jsonb as postgresJsonb } from "./internal/dsl.js"
 
 type PostgresJsonExpression<Runtime = unknown> = Expression.Scalar<
   Runtime,
-  Expression.DbType.Json<"postgres", "json" | "jsonb">,
+  Expression.DbType.Json<"postgres" | "standard", "json" | "jsonb">,
   Expression.Nullability,
   string,
   Expression.ScalarKind,
@@ -31,10 +32,24 @@ type PostgresJsonbExpression<Runtime = unknown> = Expression.Scalar<
 
 type ExactJsonPathInput = JsonPath.ExactSegment | JsonPath.Path<any>
 
+type JsonPathPredicateExpression = Expression.Scalar<
+  string | null,
+  Expression.DbType.Any,
+  Expression.Nullability,
+  string,
+  Expression.ScalarKind,
+  Expression.BindingId
+>
+
+type JsonPathPredicateQuery = JsonPath.Path<any> | JsonPathPredicateExpression | string
+
+type JsonPathPredicateQueryInput<Query extends JsonPathPredicateQuery> =
+  Query extends string ? LiteralStringInput<Query> : Query
+
 type ExactJsonPathUsageError<Target> = {
   readonly __effect_qb_error__: "effect-qb: postgres json helpers only accept exact key/index paths"
   readonly __effect_qb_json_path__: Target
-  readonly __effect_qb_hint__: "Use Postgres.Json.jsonb.path(...) when you need wildcard(), slice(), or descend() segments"
+  readonly __effect_qb_hint__: "Use Postgres.Jsonb.path(...) when you need wildcard(), slice(), or descend() segments"
 }
 
 type ExactJsonPathGuard<Target> = Target extends JsonPath.Path<any>
@@ -141,7 +156,7 @@ type JsonbOnlyUsageError<
   readonly __effect_qb_error__: "effect-qb: postgres jsonb helpers require a jsonb expression"
   readonly __effect_qb_json_operation__: Operation
   readonly __effect_qb_received_kind__: Expression.DbTypeOf<Value>["kind"]
-  readonly __effect_qb_hint__: "Use Column.jsonb(...), Cast.to(..., Type.jsonb()), or Postgres.Json.jsonb.toJsonb(...)"
+  readonly __effect_qb_hint__: "Use Column.jsonb(...), Cast.to(..., Type.jsonb()), or Postgres.Jsonb.toJsonb(...)"
 }
 
 type JsonbBaseGuard<
@@ -514,20 +529,41 @@ const jsonb = {
     base: Base & JsonbBaseGuard<Base, "jsonb.stripNulls">
   ) => postgresJsonb.stripNulls(base as Base),
   pathExists: <
-    Base extends PostgresJsonExpression<any>
+    Base extends PostgresJsonExpression<any>,
+    Query extends JsonPathPredicateQuery
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.pathExists">,
-    query: Parameters<typeof postgresJsonb.pathExists>[1]
+    query: JsonPathPredicateQueryInput<Query>
   ) => postgresJsonb.pathExists(base as Base, query),
   pathMatch: <
-    Base extends PostgresJsonExpression<any>
+    Base extends PostgresJsonExpression<any>,
+    Query extends JsonPathPredicateQuery
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.pathMatch">,
-    query: Parameters<typeof postgresJsonb.pathMatch>[1]
+    query: JsonPathPredicateQueryInput<Query>
   ) => postgresJsonb.pathMatch(base as Base, query)
 }
 
 /** Postgres shared JSON helpers for exact paths and functions that work on both json and jsonb. */
 export { json }
+export const key = json.key
+export const index = json.index
+export const path = json.path
+export const get = json.get
+export const access = json.access
+export const traverse = json.traverse
+export const text = json.text
+export const accessText = json.accessText
+export const traverseText = json.traverseText
+export const buildObject = json.buildObject
+export const buildArray = json.buildArray
+export const toJson = json.toJson
+export const typeOf = json.typeOf
+export const length = json.length
+export const keys = json.keys
+export const stripNulls = json.stripNulls
+export const delete_ = json.delete
+export { delete_ as delete }
+export const remove = json.remove
 /** Postgres jsonb-only helpers for containment, mutation, wildcard paths, and SQL/JSON path predicates. */
 export { jsonb }

package/src/postgres/jsonb.ts

@@ -0,0 +1,38 @@
+import { jsonb } from "./json.js"
+
+/** Postgres jsonb-only helpers for containment, mutation, wildcard paths, and SQL/JSON path predicates. */
+export { jsonb }
+export const key = jsonb.key
+export const index = jsonb.index
+export const wildcard = jsonb.wildcard
+export const slice = jsonb.slice
+export const descend = jsonb.descend
+export const path = jsonb.path
+export const get = jsonb.get
+export const access = jsonb.access
+export const traverse = jsonb.traverse
+export const text = jsonb.text
+export const accessText = jsonb.accessText
+export const traverseText = jsonb.traverseText
+export const contains = jsonb.contains
+export const containedBy = jsonb.containedBy
+export const hasKey = jsonb.hasKey
+export const keyExists = jsonb.keyExists
+export const hasAnyKeys = jsonb.hasAnyKeys
+export const hasAllKeys = jsonb.hasAllKeys
+export const delete_ = jsonb.delete
+export { delete_ as delete }
+export const remove = jsonb.remove
+export const set = jsonb.set
+export const insert = jsonb.insert
+export const concat = jsonb.concat
+export const merge = jsonb.merge
+export const buildObject = jsonb.buildObject
+export const buildArray = jsonb.buildArray
+export const toJsonb = jsonb.toJsonb
+export const typeOf = jsonb.typeOf
+export const length = jsonb.length
+export const keys = jsonb.keys
+export const stripNulls = jsonb.stripNulls
+export const pathExists = jsonb.pathExists
+export const pathMatch = jsonb.pathMatch

package/src/postgres/query-extension.ts

@@ -0,0 +1,2 @@
+/** Postgres-only query helpers. Portable query builders are exported from the root package. */
+export { distinctOn, generateSeries, onConflict } from "./query.js"

package/src/postgres/renderer.ts

@@ -1,5 +1,9 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
 import * as CoreRenderer from "../internal/renderer.js"
+import * as Casing from "../internal/casing.js"
 import type * as Expression from "../internal/scalar.js"
+import type { PostgresDatatypeFamily, PostgresDatatypeKind } from "./datatypes/spec.js"
 import { renderPostgresPlan } from "./internal/renderer.js"
 
 /** Postgres-specialized rendered query shape. */
@@ -7,18 +11,41 @@ export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "postgres">
 /** Extracts the row type carried by a Postgres rendered query. */
 export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 /** Postgres-specialized renderer contract. */
-export type Renderer = CoreRenderer.Renderer<"postgres">
+export type Renderer = CoreRenderer.Renderer<"postgres"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
+
+export type ValueMappings = Expression.DriverValueMappingsFor<PostgresDatatypeKind, PostgresDatatypeFamily>
 
 export interface MakeOptions {
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
+  readonly casing?: Casing.Options
 }
 
 export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
+const RendererProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
 /** Creates the built-in Postgres renderer. */
-export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, options))
+export const make = (options: MakeOptions = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, options))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: options.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      make({
+        ...options,
+        casing: Casing.merge(options.casing, override)
+      })
+  }) as Renderer
+}
 
 /** Shared built-in Postgres renderer instance. */
 export const postgres = make()

package/src/postgres/schema-management.ts

@@ -3,6 +3,7 @@ import { pipeArguments, type Pipeable } from "effect/Pipeable"
 
 import type * as Expression from "../internal/scalar.js"
 import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
 
 export const EnumTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Enum")
 export const SequenceTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Sequence")
@@ -121,7 +122,7 @@ const renderQualifiedTypeName = (
     : `${renderIdentifier(schemaName)}.${renderIdentifier(name)}`
 
 const EnumProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   },
   qualifiedName(this: EnumDefinition) {
@@ -137,7 +138,11 @@ const EnumProto = {
     }
   },
   column(this: EnumDefinition) {
-    const values = this.values.map((value) => Schema.Literal(value)) as unknown as readonly [Schema.Schema.Any, ...Schema.Schema.Any[]]
+    const [first, ...rest] = this.values
+    const values: readonly [Schema.Schema.Any, ...Schema.Schema.Any[]] = [
+      Schema.Literal(first),
+      ...rest.map((value) => Schema.Literal(value))
+    ]
     return makeColumnDefinition(
       values.length === 1 ? values[0]! : Schema.Union(...values),
       {
@@ -161,7 +166,7 @@ const EnumProto = {
 }
 
 const SequenceProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   },
   qualifiedName(this: SequenceDefinition) {
@@ -212,7 +217,7 @@ export function enumType<
   Name extends string,
   const Values extends readonly [string, ...string[]]
 >(
-  name: Name,
+  name: NonEmptyStringInput<Name>,
   values: Values
 ): EnumDefinition<Name, Values, undefined>
 export function enumType<
@@ -220,9 +225,9 @@ export function enumType<
   const Values extends readonly [string, ...string[]],
   SchemaName extends string
 >(
-  name: Name,
+  name: NonEmptyStringInput<Name>,
   values: Values,
-  schemaName: SchemaName
+  schemaName: NonEmptyStringInput<SchemaName>
 ): EnumDefinition<Name, Values, SchemaName>
 export function enumType(
   name: string,
@@ -243,11 +248,11 @@ export function enumType(
 }
 
 export function sequence<Name extends string>(
-  name: Name
+  name: NonEmptyStringInput<Name>
 ): SequenceDefinition<Name, undefined>
 export function sequence<Name extends string, SchemaName extends string>(
-  name: Name,
-  schemaName: SchemaName
+  name: NonEmptyStringInput<Name>,
+  schemaName: NonEmptyStringInput<SchemaName>
 ): SequenceDefinition<Name, SchemaName>
 export function sequence(
   name: string,
@@ -265,21 +270,21 @@ export function sequence(
 }
 
 export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
+  schemaName: NonEmptyStringInput<SchemaName>
 ) => ({
   schemaName,
   enumType: <
     Name extends string,
     const Values extends readonly [string, ...string[]]
   >(
-    name: Name,
+    name: NonEmptyStringInput<Name>,
     values: Values
   ): EnumDefinition<Name, Values, SchemaName> =>
     enumType(name, values, schemaName) as EnumDefinition<Name, Values, SchemaName>,
   sequence: <
     Name extends string
   >(
-    name: Name
+    name: NonEmptyStringInput<Name>
   ): SequenceDefinition<Name, SchemaName> =>
     sequence(name, schemaName) as SequenceDefinition<Name, SchemaName>
 })