@prisma-next/adapter-postgres 0.3.0-pr.99.6 → 0.3.0

package/dist/adapter-7pXt8ej9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-7pXt8ej9.mjs","names":["parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor>","codec","paramIndexMap: ParamIndexMap","params: unknown[]","sql: string","right: string","orderedColumns: string[]","value: string"],"sources":["../src/core/adapter.ts"],"sourcesContent":["import {\n  type Adapter,\n  type AdapterProfile,\n  type AggregateExpr,\n  type AnyExpression,\n  type AnyFromSource,\n  type AnyQueryAst,\n  type BinaryExpr,\n  type CodecParamsDescriptor,\n  type ColumnRef,\n  createCodecRegistry,\n  type DeleteAst,\n  type InsertAst,\n  type InsertValue,\n  type JoinAst,\n  type JoinOnExpr,\n  type JsonArrayAggExpr,\n  type JsonObjectExpr,\n  type ListExpression,\n  LiteralExpr,\n  type LowererContext,\n  type NullCheckExpr,\n  type OperationExpr,\n  type OrderByItem,\n  type ParamRef,\n  type ProjectionItem,\n  type SelectAst,\n  type SubqueryExpr,\n  type UpdateAst,\n} from '@prisma-next/sql-relational-core/ast';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from './codec-ids';\nimport { codecDefinitions } from './codecs';\nimport { escapeLiteral, quoteIdentifier } from './sql-utils';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst VECTOR_CODEC_ID = 'pg/vector@1' as const;\n\nfunction getCodecParamCast(codecId: string | undefined): string | undefined {\n  if (codecId === VECTOR_CODEC_ID) {\n    return 'vector';\n  }\n  if (codecId === PG_JSON_CODEC_ID) {\n    return 'json';\n  }\n  if (codecId === PG_JSONB_CODEC_ID) {\n    return 'jsonb';\n  }\n  return undefined;\n}\n\nfunction renderTypedParam(index: number, codecId: string | undefined): string {\n  const cast = getCodecParamCast(codecId);\n  return cast ? `$${index}::${cast}` : `$${index}`;\n}\n\ntype ParamIndexMap = Map<ParamRef, number>;\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n  },\n});\n\ntype AdapterCodec = (typeof codecDefinitions)[keyof typeof codecDefinitions]['codec'];\ntype ParameterizedCodec = AdapterCodec & {\n  readonly paramsSchema: NonNullable<AdapterCodec['paramsSchema']>;\n};\n\nconst parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor> = Object.values(codecDefinitions)\n  .map((definition) => definition.codec)\n  .filter((codec): codec is ParameterizedCodec => codec.paramsSchema !== undefined)\n  .map((codec) =>\n    Object.freeze({\n      codecId: codec.id,\n      paramsSchema: codec.paramsSchema,\n      ...ifDefined('init', codec.init),\n    }),\n  );\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with\n  // RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecRegistry = (() => {\n    const registry = createCodecRegistry();\n    for (const definition of Object.values(codecDefinitions)) {\n      registry.register(definition.codec);\n    }\n    return registry;\n  })();\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      codecs: () => this.codecRegistry,\n      readMarkerStatement: () => ({\n        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',\n        params: [1],\n      }),\n    });\n  }\n\n  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {\n    return parameterizedCodecs;\n  }\n\n  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>) {\n    const collectedParamRefs = ast.collectParamRefs();\n    const paramIndexMap: ParamIndexMap = new Map();\n    const params: unknown[] = [];\n    for (const ref of collectedParamRefs) {\n      if (paramIndexMap.has(ref)) {\n        continue;\n      }\n      paramIndexMap.set(ref, params.length + 1);\n      params.push(ref.value);\n    }\n\n    let sql: string;\n\n    const node = ast;\n    switch (node.kind) {\n      case 'select':\n        sql = renderSelect(node, context.contract, paramIndexMap);\n        break;\n      case 'insert':\n        sql = renderInsert(node, context.contract, paramIndexMap);\n        break;\n      case 'update':\n        sql = renderUpdate(node, context.contract, paramIndexMap);\n        break;\n      case 'delete':\n        sql = renderDelete(node, context.contract, paramIndexMap);\n        break;\n      // v8 ignore next 4\n      default:\n        throw new Error(\n          `Unsupported AST node kind: ${(node satisfies never as { kind: string }).kind}`,\n        );\n    }\n\n    return Object.freeze({\n      profileId: this.profile.id,\n      body: Object.freeze({ sql, params }),\n    });\n  }\n}\n\nfunction renderSelect(ast: SelectAst, contract?: PostgresContract, pim?: ParamIndexMap): string {\n  const selectClause = `SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(\n    ast.projection,\n    contract,\n    pim,\n  )}`;\n  const fromClause = `FROM ${renderSource(ast.from, contract, pim)}`;\n\n  const joinsClause = ast.joins?.length\n    ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(' ')\n    : '';\n\n  const whereClause = ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : '';\n  const groupByClause = ast.groupBy?.length\n    ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(', ')}`\n    : '';\n  const havingClause = ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : '';\n  const orderClause = ast.orderBy?.length\n    ? `ORDER BY ${ast.orderBy\n        .map((order) => {\n          const expr = renderExpr(order.expr, contract, pim);\n          return `${expr} ${order.dir.toUpperCase()}`;\n        })\n        .join(', ')}`\n    : '';\n  const limitClause = typeof ast.limit === 'number' ? `LIMIT ${ast.limit}` : '';\n  const offsetClause = typeof ast.offset === 'number' ? `OFFSET ${ast.offset}` : '';\n\n  const clauses = [\n    selectClause,\n    fromClause,\n    joinsClause,\n    whereClause,\n    groupByClause,\n    havingClause,\n    orderClause,\n    limitClause,\n    offsetClause,\n  ]\n    .filter((part) => part.length > 0)\n    .join(' ');\n  return clauses.trim();\n}\n\nfunction renderProjection(\n  projection: ReadonlyArray<ProjectionItem>,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  return projection\n    .map((item) => {\n      const alias = quoteIdentifier(item.alias);\n      if (item.expr.kind === 'literal') {\n        return `${renderLiteral(item.expr)} AS ${alias}`;\n      }\n      return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;\n    })\n    .join(', ');\n}\n\nfunction renderDistinctPrefix(\n  distinct: true | undefined,\n  distinctOn: ReadonlyArray<AnyExpression> | undefined,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  if (distinctOn && distinctOn.length > 0) {\n    const rendered = distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(', ');\n    return `DISTINCT ON (${rendered}) `;\n  }\n  if (distinct) {\n    return 'DISTINCT ';\n  }\n  return '';\n}\n\nfunction renderSource(\n  source: AnyFromSource,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  const node = source;\n  switch (node.kind) {\n    case 'table-source': {\n      const table = quoteIdentifier(node.name);\n      if (!node.alias) {\n        return table;\n      }\n      return `${table} AS ${quoteIdentifier(node.alias)}`;\n    }\n    case 'derived-table-source':\n      return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported source node kind: ${(node satisfies never as { kind: string }).kind}`,\n      );\n  }\n}\n\nfunction assertScalarSubquery(query: SelectAst): void {\n  if (query.projection.length !== 1) {\n    throw new Error('Subquery expressions must project exactly one column');\n  }\n}\n\nfunction renderSubqueryExpr(\n  expr: SubqueryExpr,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  assertScalarSubquery(expr.query);\n  return `(${renderSelect(expr.query, contract, pim)})`;\n}\n\nfunction renderWhere(\n  expr: AnyExpression,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  return renderExpr(expr, contract, pim);\n}\n\nfunction renderNullCheck(\n  expr: NullCheckExpr,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  const rendered = renderExpr(expr.expr, contract, pim);\n  const renderedExpr =\n    expr.expr.kind === 'operation' || expr.expr.kind === 'subquery' ? `(${rendered})` : rendered;\n  return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;\n}\n\nfunction renderBinary(expr: BinaryExpr, contract?: PostgresContract, pim?: ParamIndexMap): string {\n  if (expr.right.kind === 'list' && expr.right.values.length === 0) {\n    if (expr.op === 'in') {\n      return 'FALSE';\n    }\n    if (expr.op === 'notIn') {\n      return 'TRUE';\n    }\n  }\n\n  const leftExpr = expr.left;\n  const left = renderExpr(leftExpr, contract, pim);\n  const leftRendered =\n    leftExpr.kind === 'operation' || leftExpr.kind === 'subquery' ? `(${left})` : left;\n\n  const rightNode = expr.right;\n  let right: string;\n  switch (rightNode.kind) {\n    case 'list':\n      right = renderListLiteral(rightNode, pim);\n      break;\n    case 'literal':\n      right = renderLiteral(rightNode);\n      break;\n    case 'column-ref':\n      right = renderColumn(rightNode);\n      break;\n    case 'param-ref':\n      right = renderParamRef(rightNode, pim);\n      break;\n    default:\n      right = renderExpr(rightNode, contract, pim);\n      break;\n  }\n\n  const operatorMap: Record<BinaryExpr['op'], string> = {\n    eq: '=',\n    neq: '!=',\n    gt: '>',\n    lt: '<',\n    gte: '>=',\n    lte: '<=',\n    like: 'LIKE',\n    ilike: 'ILIKE',\n    in: 'IN',\n    notIn: 'NOT IN',\n  };\n\n  return `${leftRendered} ${operatorMap[expr.op]} ${right}`;\n}\n\nfunction renderListLiteral(expr: ListExpression, pim?: ParamIndexMap): string {\n  if (expr.values.length === 0) {\n    return '(NULL)';\n  }\n  const values = expr.values\n    .map((v) => {\n      if (v.kind === 'param-ref') return renderParamRef(v, pim);\n      if (v.kind === 'literal') return renderLiteral(v);\n      return renderExpr(v, undefined, pim);\n    })\n    .join(', ');\n  return `(${values})`;\n}\n\nfunction renderColumn(ref: ColumnRef): string {\n  if (ref.table === 'excluded') {\n    return `excluded.${quoteIdentifier(ref.column)}`;\n  }\n  return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;\n}\n\nfunction renderAggregateExpr(\n  expr: AggregateExpr,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  const fn = expr.fn.toUpperCase();\n  if (!expr.expr) {\n    return `${fn}(*)`;\n  }\n  return `${fn}(${renderExpr(expr.expr, contract, pim)})`;\n}\n\nfunction renderJsonObjectExpr(\n  expr: JsonObjectExpr,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  const args = expr.entries\n    .flatMap((entry): [string, string] => {\n      const key = `'${escapeLiteral(entry.key)}'`;\n      if (entry.value.kind === 'literal') {\n        return [key, renderLiteral(entry.value)];\n      }\n      return [key, renderExpr(entry.value, contract, pim)];\n    })\n    .join(', ');\n  return `json_build_object(${args})`;\n}\n\nfunction renderOrderByItems(\n  items: ReadonlyArray<OrderByItem>,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  return items\n    .map((item) => `${renderExpr(item.expr, contract, pim)} ${item.dir.toUpperCase()}`)\n    .join(', ');\n}\n\nfunction renderJsonArrayAggExpr(\n  expr: JsonArrayAggExpr,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  const aggregateOrderBy =\n    expr.orderBy && expr.orderBy.length > 0\n      ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}`\n      : '';\n  const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;\n  if (expr.onEmpty === 'emptyArray') {\n    return `coalesce(${aggregated}, json_build_array())`;\n  }\n  return aggregated;\n}\n\nfunction renderExpr(expr: AnyExpression, contract?: PostgresContract, pim?: ParamIndexMap): string {\n  const node = expr;\n  switch (node.kind) {\n    case 'column-ref':\n      return renderColumn(node);\n    case 'identifier-ref':\n      return quoteIdentifier(node.name);\n    case 'operation':\n      return renderOperation(node, contract, pim);\n    case 'subquery':\n      return renderSubqueryExpr(node, contract, pim);\n    case 'aggregate':\n      return renderAggregateExpr(node, contract, pim);\n    case 'json-object':\n      return renderJsonObjectExpr(node, contract, pim);\n    case 'json-array-agg':\n      return renderJsonArrayAggExpr(node, contract, pim);\n    case 'binary':\n      return renderBinary(node, contract, pim);\n    case 'and':\n      if (node.exprs.length === 0) {\n        return 'TRUE';\n      }\n      return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(' AND ')})`;\n    case 'or':\n      if (node.exprs.length === 0) {\n        return 'FALSE';\n      }\n      return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(' OR ')})`;\n    case 'exists': {\n      const notKeyword = node.notExists ? 'NOT ' : '';\n      const subquery = renderSelect(node.subquery, contract, pim);\n      return `${notKeyword}EXISTS (${subquery})`;\n    }\n    case 'null-check':\n      return renderNullCheck(node, contract, pim);\n    case 'not':\n      return `NOT (${renderExpr(node.expr, contract, pim)})`;\n    case 'param-ref':\n      return renderParamRef(node, pim);\n    case 'literal':\n      return renderLiteral(node);\n    case 'list':\n      return renderListLiteral(node, pim);\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported expression node kind: ${(node satisfies never as { kind: string }).kind}`,\n      );\n  }\n}\n\nfunction renderParamRef(ref: ParamRef, pim?: ParamIndexMap): string {\n  const index = pim?.get(ref);\n  if (index === undefined) {\n    throw new Error('ParamRef not found in index map');\n  }\n  return renderTypedParam(index, ref.codecId);\n}\n\nfunction renderLiteral(expr: LiteralExpr): string {\n  if (typeof expr.value === 'string') {\n    return `'${escapeLiteral(expr.value)}'`;\n  }\n  if (typeof expr.value === 'number' || typeof expr.value === 'boolean') {\n    return String(expr.value);\n  }\n  if (typeof expr.value === 'bigint') {\n    return String(expr.value);\n  }\n  if (expr.value === null) {\n    return 'NULL';\n  }\n  if (expr.value === undefined) {\n    return 'NULL';\n  }\n  if (expr.value instanceof Date) {\n    return `'${escapeLiteral(expr.value.toISOString())}'`;\n  }\n  if (Array.isArray(expr.value)) {\n    return `ARRAY[${expr.value.map((v: unknown) => renderLiteral(new LiteralExpr(v))).join(', ')}]`;\n  }\n  const json = JSON.stringify(expr.value);\n  if (json === undefined) {\n    return 'NULL';\n  }\n  return `'${escapeLiteral(json)}'`;\n}\n\nfunction renderOperation(\n  expr: OperationExpr,\n  contract?: PostgresContract,\n  pim?: ParamIndexMap,\n): string {\n  const self = renderExpr(expr.self, contract, pim);\n  const args = expr.args.map((arg) => {\n    return renderExpr(arg, contract, pim);\n  });\n\n  let result = expr.lowering.template;\n  result = result.replace(/\\{\\{self\\}\\}/g, self);\n  for (let i = 0; i < args.length; i++) {\n    result = result.replace(new RegExp(`\\\\{\\\\{arg${i}\\\\}\\\\}`, 'g'), args[i] ?? '');\n  }\n\n  return result;\n}\n\nfunction renderJoin(join: JoinAst, contract?: PostgresContract, pim?: ParamIndexMap): string {\n  const joinType = join.joinType.toUpperCase();\n  const lateral = join.lateral ? 'LATERAL ' : '';\n  const source = renderSource(join.source, contract, pim);\n  const onClause = renderJoinOn(join.on, contract, pim);\n  return `${joinType} JOIN ${lateral}${source} ON ${onClause}`;\n}\n\nfunction renderJoinOn(on: JoinOnExpr, contract?: PostgresContract, pim?: ParamIndexMap): string {\n  if (on.kind === 'eq-col-join-on') {\n    const left = renderColumn(on.left);\n    const right = renderColumn(on.right);\n    return `${left} = ${right}`;\n  }\n  return renderWhere(on, contract, pim);\n}\n\nfunction getInsertColumnOrder(\n  rows: ReadonlyArray<Record<string, InsertValue>>,\n  contract: PostgresContract,\n  tableName: string,\n): string[] {\n  const orderedColumns: string[] = [];\n  const seenColumns = new Set<string>();\n\n  for (const row of rows) {\n    for (const column of Object.keys(row)) {\n      if (seenColumns.has(column)) {\n        continue;\n      }\n      seenColumns.add(column);\n      orderedColumns.push(column);\n    }\n  }\n\n  if (orderedColumns.length > 0) {\n    return orderedColumns;\n  }\n\n  return Object.keys(contract.storage.tables[tableName]?.columns ?? {});\n}\n\nfunction renderInsertValue(value: InsertValue | undefined, pim?: ParamIndexMap): string {\n  if (!value || value.kind === 'default-value') {\n    return 'DEFAULT';\n  }\n\n  switch (value.kind) {\n    case 'param-ref':\n      return renderParamRef(value, pim);\n    case 'column-ref':\n      return renderColumn(value);\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported value node in INSERT: ${(value satisfies never as { kind: string }).kind}`,\n      );\n  }\n}\n\nfunction renderInsert(ast: InsertAst, contract: PostgresContract, pim?: ParamIndexMap): string {\n  const table = quoteIdentifier(ast.table.name);\n  const rows = ast.rows;\n  if (rows.length === 0) {\n    throw new Error('INSERT requires at least one row');\n  }\n  const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);\n  const insertClause = (() => {\n    if (!hasExplicitValues) {\n      if (rows.length === 1) {\n        return `INSERT INTO ${table} DEFAULT VALUES`;\n      }\n\n      const defaultColumns = getInsertColumnOrder(rows, contract, ast.table.name);\n      if (defaultColumns.length === 0) {\n        return `INSERT INTO ${table} VALUES ${rows.map(() => '()').join(', ')}`;\n      }\n\n      const quotedColumns = defaultColumns.map((column) => quoteIdentifier(column));\n      const defaultRow = `(${defaultColumns.map(() => 'DEFAULT').join(', ')})`;\n      return `INSERT INTO ${table} (${quotedColumns.join(', ')}) VALUES ${rows\n        .map(() => defaultRow)\n        .join(', ')}`;\n    }\n\n    const columnOrder = getInsertColumnOrder(rows, contract, ast.table.name);\n    const columns = columnOrder.map((column) => quoteIdentifier(column));\n    const values = rows\n      .map((row) => {\n        const renderedRow = columnOrder.map((column) => renderInsertValue(row[column], pim));\n        return `(${renderedRow.join(', ')})`;\n      })\n      .join(', ');\n\n    return `INSERT INTO ${table} (${columns.join(', ')}) VALUES ${values}`;\n  })();\n  const onConflictClause = ast.onConflict\n    ? (() => {\n        const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));\n        if (conflictColumns.length === 0) {\n          throw new Error('INSERT onConflict requires at least one conflict column');\n        }\n\n        const action = ast.onConflict.action;\n        switch (action.kind) {\n          case 'do-nothing':\n            return ` ON CONFLICT (${conflictColumns.join(', ')}) DO NOTHING`;\n          case 'do-update-set': {\n            const updates = Object.entries(action.set).map(([colName, value]) => {\n              const target = quoteIdentifier(colName);\n              if (value.kind === 'param-ref') {\n                return `${target} = ${renderParamRef(value, pim)}`;\n              }\n              return `${target} = ${renderColumn(value)}`;\n            });\n            return ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${updates.join(', ')}`;\n          }\n          // v8 ignore next 4\n          default:\n            throw new Error(\n              `Unsupported onConflict action: ${(action satisfies never as { kind: string }).kind}`,\n            );\n        }\n      })()\n    : '';\n  const returningClause = ast.returning?.length\n    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`\n    : '';\n\n  return `${insertClause}${onConflictClause}${returningClause}`;\n}\n\nfunction renderUpdate(ast: UpdateAst, contract: PostgresContract, pim?: ParamIndexMap): string {\n  const table = quoteIdentifier(ast.table.name);\n  const setClauses = Object.entries(ast.set).map(([col, val]) => {\n    const column = quoteIdentifier(col);\n    let value: string;\n    switch (val.kind) {\n      case 'param-ref':\n        value = renderParamRef(val, pim);\n        break;\n      case 'column-ref':\n        value = renderColumn(val);\n        break;\n      // v8 ignore next 4\n      default:\n        throw new Error(\n          `Unsupported value node in UPDATE: ${(val satisfies never as { kind: string }).kind}`,\n        );\n    }\n    return `${column} = ${value}`;\n  });\n\n  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';\n  const returningClause = ast.returning?.length\n    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`\n    : '';\n\n  return `UPDATE ${table} SET ${setClauses.join(', ')}${whereClause}${returningClause}`;\n}\n\nfunction renderDelete(ast: DeleteAst, contract?: PostgresContract, pim?: ParamIndexMap): string {\n  const table = quoteIdentifier(ast.table.name);\n  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';\n  const returningClause = ast.returning?.length\n    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`\n    : '';\n\n  return `DELETE FROM ${table}${whereClause}${returningClause}`;\n}\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":"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"}

package/dist/adapter.d.mts

@@ -0,0 +1,23 @@
+import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-DxaTd7aP.mjs";
+import { Adapter, AdapterProfile, AnyQueryAst, CodecParamsDescriptor, LowererContext } from "@prisma-next/sql-relational-core/ast";
+
+//#region src/core/adapter.d.ts
+declare class PostgresAdapterImpl implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  readonly profile: AdapterProfile<'postgres'>;
+  private readonly codecRegistry;
+  constructor(options?: PostgresAdapterOptions);
+  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor>;
+  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): Readonly<{
+    profileId: string;
+    body: Readonly<{
+      sql: string;
+      params: unknown[];
+    }>;
+  }>;
+}
+declare function createPostgresAdapter(options?: PostgresAdapterOptions): Readonly<PostgresAdapterImpl>;
+//#endregion
+export { createPostgresAdapter };
+//# sourceMappingURL=adapter.d.mts.map

package/dist/adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":[],"mappings":";;;;cAyFM,mBAAA,YACO,QAAQ,aAAa,kBAAkB;;EAD9C,SAAA,QAAA,EAAA,UACJ;EAAmB,SAAA,OAAA,EAOD,cAPC,CAAA,UAAA,CAAA;EAAa,iBAAA,aAAA;EAAkB,WAAA,CAAA,OAAA,CAAA,EAgB5B,sBAhB4B;EAOhC,mBAAA,CAAA,CAAA,EAsBK,aAtBL,CAsBmB,qBAtBnB,CAAA;EASI,KAAA,CAAA,GAAA,EAiBX,WAjBW,EAAA,OAAA,EAiBW,cAjBX,CAiB0B,gBAjB1B,CAAA,CAAA,EAiB2C,QAjB3C,CAAA;IAae,SAAA,EAAA,MAAA;IAAd,IAAA,UAAA,CAAA;MAIZ,GAAA,EAAA,MAAA;MAAqC,MAAA,EAAA,OAAA,EAAA;IAAf,CAAA,CAAA;;;AAjCtB,iBAumBG,qBAAA,CAvmBH,OAAA,CAAA,EAumBmC,sBAvmBnC,CAAA,EAumByD,QAvmBzD,CAumByD,mBAvmBzD,CAAA"}

package/dist/adapter.mjs

@@ -0,0 +1,3 @@
+import { t as createPostgresAdapter } from "./adapter-7pXt8ej9.mjs";
+
+export { createPostgresAdapter };

package/dist/codec-ids-BwjcIf74.mjs

@@ -0,0 +1,29 @@
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/sql-relational-core/ast";
+
+//#region src/core/codec-ids.ts
+const PG_TEXT_CODEC_ID = "pg/text@1";
+const PG_ENUM_CODEC_ID = "pg/enum@1";
+const PG_CHAR_CODEC_ID = "pg/char@1";
+const PG_VARCHAR_CODEC_ID = "pg/varchar@1";
+const PG_INT_CODEC_ID = "pg/int@1";
+const PG_INT2_CODEC_ID = "pg/int2@1";
+const PG_INT4_CODEC_ID = "pg/int4@1";
+const PG_INT8_CODEC_ID = "pg/int8@1";
+const PG_FLOAT_CODEC_ID = "pg/float@1";
+const PG_FLOAT4_CODEC_ID = "pg/float4@1";
+const PG_FLOAT8_CODEC_ID = "pg/float8@1";
+const PG_NUMERIC_CODEC_ID = "pg/numeric@1";
+const PG_BOOL_CODEC_ID = "pg/bool@1";
+const PG_BIT_CODEC_ID = "pg/bit@1";
+const PG_VARBIT_CODEC_ID = "pg/varbit@1";
+const PG_TIMESTAMP_CODEC_ID = "pg/timestamp@1";
+const PG_TIMESTAMPTZ_CODEC_ID = "pg/timestamptz@1";
+const PG_TIME_CODEC_ID = "pg/time@1";
+const PG_TIMETZ_CODEC_ID = "pg/timetz@1";
+const PG_INTERVAL_CODEC_ID = "pg/interval@1";
+const PG_JSON_CODEC_ID = "pg/json@1";
+const PG_JSONB_CODEC_ID = "pg/jsonb@1";
+
+//#endregion
+export { SQL_CHAR_CODEC_ID as C, SQL_TIMESTAMP_CODEC_ID as D, SQL_TEXT_CODEC_ID as E, SQL_VARCHAR_CODEC_ID as O, PG_VARCHAR_CODEC_ID as S, SQL_INT_CODEC_ID as T, PG_TIMESTAMPTZ_CODEC_ID as _, PG_FLOAT4_CODEC_ID as a, PG_TIME_CODEC_ID as b, PG_INT2_CODEC_ID as c, PG_INTERVAL_CODEC_ID as d, PG_INT_CODEC_ID as f, PG_TEXT_CODEC_ID as g, PG_NUMERIC_CODEC_ID as h, PG_ENUM_CODEC_ID as i, PG_INT4_CODEC_ID as l, PG_JSON_CODEC_ID as m, PG_BOOL_CODEC_ID as n, PG_FLOAT8_CODEC_ID as o, PG_JSONB_CODEC_ID as p, PG_CHAR_CODEC_ID as r, PG_FLOAT_CODEC_ID as s, PG_BIT_CODEC_ID as t, PG_INT8_CODEC_ID as u, PG_TIMESTAMP_CODEC_ID as v, SQL_FLOAT_CODEC_ID as w, PG_VARBIT_CODEC_ID as x, PG_TIMETZ_CODEC_ID as y };
+//# sourceMappingURL=codec-ids-BwjcIf74.mjs.map

package/dist/codec-ids-BwjcIf74.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-BwjcIf74.mjs","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":["export {\n  SQL_CHAR_CODEC_ID,\n  SQL_FLOAT_CODEC_ID,\n  SQL_INT_CODEC_ID,\n  SQL_TEXT_CODEC_ID,\n  SQL_TIMESTAMP_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/sql-relational-core/ast';\nexport const PG_TEXT_CODEC_ID = 'pg/text@1' as const;\nexport const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;\nexport const PG_CHAR_CODEC_ID = 'pg/char@1' as const;\nexport const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;\nexport const PG_INT_CODEC_ID = 'pg/int@1' as const;\nexport const PG_INT2_CODEC_ID = 'pg/int2@1' as const;\nexport const PG_INT4_CODEC_ID = 'pg/int4@1' as const;\nexport const PG_INT8_CODEC_ID = 'pg/int8@1' as const;\nexport const PG_FLOAT_CODEC_ID = 'pg/float@1' as const;\nexport const PG_FLOAT4_CODEC_ID = 'pg/float4@1' as const;\nexport const PG_FLOAT8_CODEC_ID = 'pg/float8@1' as const;\nexport const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;\nexport const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;\nexport const PG_BIT_CODEC_ID = 'pg/bit@1' as const;\nexport const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;\nexport const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;\nexport const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;\nexport const PG_TIME_CODEC_ID = 'pg/time@1' as const;\nexport const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;\nexport const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;\nexport const PG_JSON_CODEC_ID = 'pg/json@1' as const;\nexport const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;\n"],"mappings":";;;AAQA,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,sBAAsB;AACnC,MAAa,kBAAkB;AAC/B,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB;AACjC,MAAa,qBAAqB;AAClC,MAAa,qBAAqB;AAClC,MAAa,sBAAsB;AACnC,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAC/B,MAAa,qBAAqB;AAClC,MAAa,wBAAwB;AACrC,MAAa,0BAA0B;AACvC,MAAa,mBAAmB;AAChC,MAAa,qBAAqB;AAClC,MAAa,uBAAuB;AACpC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB"}

package/dist/codec-types.d.mts

@@ -0,0 +1,107 @@
+import * as _prisma_next_sql_relational_core_ast0 from "@prisma-next/sql-relational-core/ast";
+import { Codec } from "@prisma-next/sql-relational-core/ast";
+import { JsonValue, JsonValue as JsonValue$1 } from "@prisma-next/contract/types";
+
+//#region src/core/codecs.d.ts
+
+declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{
+  char: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  varchar: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  int: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  float: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  "sql-text": Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  "sql-timestamp": Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
+    precision?: number;
+  }, unknown>;
+  text: Codec<"pg/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  character: Codec<"pg/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  "character varying": Codec<"pg/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  integer: Codec<"pg/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  "double precision": Codec<"pg/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  int4: Codec<"pg/int4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  int2: Codec<"pg/int2@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  int8: Codec<"pg/int8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  float4: Codec<"pg/float4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  float8: Codec<"pg/float8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  numeric: Codec<"pg/numeric@1", readonly ["equality", "order", "numeric"], string, string, Record<string, unknown>, unknown>;
+  timestamp: Codec<"pg/timestamp@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
+  timestamptz: Codec<"pg/timestamptz@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
+  time: Codec<"pg/time@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  timetz: Codec<"pg/timetz@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  bool: Codec<"pg/bool@1", readonly ["equality", "boolean"], boolean, boolean, Record<string, unknown>, unknown>;
+  bit: Codec<"pg/bit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  "bit varying": Codec<"pg/varbit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  interval: Codec<"pg/interval@1", readonly ["equality", "order"], string | Record<string, unknown>, string, Record<string, unknown>, unknown>;
+  enum: Codec<"pg/enum@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  json: Codec<"pg/json@1", readonly [], string, JsonValue$1, Record<string, unknown>, unknown>;
+} & Record<"jsonb", Codec<"pg/jsonb@1", readonly ["equality"], string, JsonValue$1, Record<string, unknown>, unknown>>>;
+declare const dataTypes: {
+  readonly char: "sql/char@1";
+  readonly varchar: "sql/varchar@1";
+  readonly int: "sql/int@1";
+  readonly float: "sql/float@1";
+  readonly "sql-text": "sql/text@1";
+  readonly "sql-timestamp": "sql/timestamp@1";
+  readonly text: "pg/text@1";
+  readonly character: "pg/char@1";
+  readonly "character varying": "pg/varchar@1";
+  readonly integer: "pg/int@1";
+  readonly "double precision": "pg/float@1";
+  readonly int4: "pg/int4@1";
+  readonly int2: "pg/int2@1";
+  readonly int8: "pg/int8@1";
+  readonly float4: "pg/float4@1";
+  readonly float8: "pg/float8@1";
+  readonly numeric: "pg/numeric@1";
+  readonly timestamp: "pg/timestamp@1";
+  readonly timestamptz: "pg/timestamptz@1";
+  readonly time: "pg/time@1";
+  readonly timetz: "pg/timetz@1";
+  readonly bool: "pg/bool@1";
+  readonly bit: "pg/bit@1";
+  readonly "bit varying": "pg/varbit@1";
+  readonly interval: "pg/interval@1";
+  readonly enum: "pg/enum@1";
+  readonly json: "pg/json@1";
+  readonly jsonb: "pg/jsonb@1";
+};
+type CodecTypes$1 = typeof codecs.CodecTypes;
+//#endregion
+//#region src/exports/codec-types.d.ts
+type CodecTypes = CodecTypes$1;
+type Branded<T, Shape extends Record<string, unknown>> = T & { readonly [K in keyof Shape]: Shape[K] };
+type BrandedString<Shape extends Record<string, unknown>> = Branded<string, Shape>;
+type Char<N extends number> = BrandedString<{
+  __charLength: N;
+}>;
+type Varchar<N extends number> = BrandedString<{
+  __varcharLength: N;
+}>;
+type Numeric<P extends number, S extends number | undefined = undefined> = BrandedString<{
+  __numericPrecision: P;
+  __numericScale: S;
+}>;
+type Bit<N extends number> = BrandedString<{
+  __bitLength: N;
+}>;
+type VarBit<N extends number> = BrandedString<{
+  __varbitLength: N;
+}>;
+type Timestamp<P extends number | undefined = undefined> = BrandedString<{
+  __timestampPrecision: P;
+}>;
+type Timestamptz<P extends number | undefined = undefined> = BrandedString<{
+  __timestamptzPrecision: P;
+}>;
+type Time<P extends number | undefined = undefined> = BrandedString<{
+  __timePrecision: P;
+}>;
+type Timetz<P extends number | undefined = undefined> = BrandedString<{
+  __timetzPrecision: P;
+}>;
+type Interval<P extends number | undefined = undefined> = BrandedString<{
+  __intervalPrecision: P;
+}>;
+//#endregion
+export { Bit, Char, CodecTypes, Interval, type JsonValue, Numeric, Time, Timestamp, Timestamptz, Timetz, VarBit, Varchar, dataTypes };
+//# sourceMappingURL=codec-types.d.mts.map

package/dist/codec-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/core/codecs.ts","../src/exports/codec-types.ts"],"sourcesContent":[],"mappings":";;;;;;cAkmBM,8CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAED,YAAA,UAAoB,MAAA,CAAO;;;KCxnB3B,UAAA,GAAa;KAKpB,yBAAyB,2BAA2B,2BAClC,QAAQ,MAAM;KAGhC,4BAA4B,2BAA2B,gBAAgB;KAEhE,yBAAyB;gBAA8B;;KACvD,4BAA4B;mBAAiC;;KAC7D,sEAAsE;sBAC5D;kBACJ;;KAEN,wBAAwB;eAA6B;;KACrD,2BAA2B;kBAAgC;;KAC3D,sDAAsD;wBAC1C;;KAEZ,wDAAwD;0BAC1C;;KAEd,iDAAiD;mBAAiC;;KAClF,mDAAmD;qBAC1C;;KAET,qDAAqD;uBAC1C"}

package/dist/codec-types.mjs

@@ -0,0 +1,3 @@
+import { n as dataTypes } from "./codecs-C3wlpdV7.mjs";
+
+export { dataTypes };

package/dist/codecs-C3wlpdV7.mjs

@@ -0,0 +1,385 @@
+import { S as PG_VARCHAR_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, f as PG_INT_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, r as PG_CHAR_CODEC_ID, s as PG_FLOAT_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-BwjcIf74.mjs";
+import { codec, defineCodecs, sqlCodecDefinitions } from "@prisma-next/sql-relational-core/ast";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { type } from "arktype";
+
+//#region src/core/json-schema-type-expression.ts
+const MAX_DEPTH = 32;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function escapeStringLiteral(str) {
+	return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function quotePropertyKey(key) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeStringLiteral(key)}'`;
+}
+function renderLiteral(value) {
+	if (typeof value === "string") return `'${escapeStringLiteral(value)}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return "unknown";
+}
+function renderUnion(items, depth) {
+	return items.map((item) => render(item, depth)).join(" | ");
+}
+function renderObjectType(schema, depth) {
+	const properties = isRecord(schema["properties"]) ? schema["properties"] : {};
+	const required = Array.isArray(schema["required"]) ? new Set(schema["required"].filter((key) => typeof key === "string")) : /* @__PURE__ */ new Set();
+	const keys = Object.keys(properties).sort((left, right) => left.localeCompare(right));
+	if (keys.length === 0) {
+		const additionalProperties = schema["additionalProperties"];
+		if (additionalProperties === true || additionalProperties === void 0) return "Record<string, unknown>";
+		return `Record<string, ${render(additionalProperties, depth)}>`;
+	}
+	return `{ ${keys.map((key) => {
+		const valueSchema = properties[key];
+		const optionalMarker = required.has(key) ? "" : "?";
+		return `${quotePropertyKey(key)}${optionalMarker}: ${render(valueSchema, depth)}`;
+	}).join("; ")} }`;
+}
+function renderArrayType(schema, depth) {
+	if (Array.isArray(schema["items"])) return `readonly [${schema["items"].map((item) => render(item, depth)).join(", ")}]`;
+	if (schema["items"] !== void 0) {
+		const itemType = render(schema["items"], depth);
+		return itemType.includes(" | ") || itemType.includes(" & ") ? `(${itemType})[]` : `${itemType}[]`;
+	}
+	return "unknown[]";
+}
+function render(schema, depth) {
+	if (depth > MAX_DEPTH || !isRecord(schema)) return "JsonValue";
+	const nextDepth = depth + 1;
+	if ("const" in schema) return renderLiteral(schema["const"]);
+	if (Array.isArray(schema["enum"])) return schema["enum"].map((value) => renderLiteral(value)).join(" | ");
+	if (Array.isArray(schema["oneOf"])) return renderUnion(schema["oneOf"], nextDepth);
+	if (Array.isArray(schema["anyOf"])) return renderUnion(schema["anyOf"], nextDepth);
+	if (Array.isArray(schema["allOf"])) return schema["allOf"].map((item) => render(item, nextDepth)).join(" & ");
+	if (Array.isArray(schema["type"])) return schema["type"].map((item) => render({
+		...schema,
+		type: item
+	}, nextDepth)).join(" | ");
+	switch (schema["type"]) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "array": return renderArrayType(schema, nextDepth);
+		case "object": return renderObjectType(schema, nextDepth);
+		default: break;
+	}
+	return "JsonValue";
+}
+function renderTypeScriptTypeFromJsonSchema(schema) {
+	return render(schema, 0);
+}
+
+//#endregion
+//#region src/core/codecs.ts
+const lengthParamsSchema = type({ length: "number.integer > 0" });
+const numericParamsSchema = type({
+	precision: "number.integer > 0 & number.integer <= 1000",
+	"scale?": "number.integer >= 0"
+});
+const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
+function renderLength(typeName, typeParams) {
+	const length = typeParams["length"];
+	if (length === void 0) return;
+	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${String(length)}`);
+	return `${typeName}<${length}>`;
+}
+function renderPrecision(typeName, typeParams) {
+	const precision = typeParams["precision"];
+	if (precision === void 0) return typeName;
+	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`);
+	return `${typeName}<${precision}>`;
+}
+function renderJsonOutputType(typeParams) {
+	const typeName = typeParams["type"];
+	if (typeof typeName === "string" && typeName.trim().length > 0) return typeName.trim();
+	const schema = typeParams["schemaJson"];
+	if (schema && typeof schema === "object") return renderTypeScriptTypeFromJsonSchema(schema);
+	throw new Error(`renderOutputType: JSON codec typeParams must contain "type" (string) or "schemaJson" (object), got keys: ${Object.keys(typeParams).join(", ")}`);
+}
+function aliasCodec(base, options) {
+	return {
+		id: options.typeId,
+		targetTypes: options.targetTypes,
+		...ifDefined("meta", options.meta),
+		...ifDefined("paramsSchema", base.paramsSchema),
+		...ifDefined("init", base.init),
+		...ifDefined("encode", base.encode),
+		...ifDefined("traits", base.traits),
+		...ifDefined("renderOutputType", base.renderOutputType),
+		decode: base.decode,
+		encodeJson: base.encodeJson,
+		decodeJson: base.decodeJson
+	};
+}
+const sqlCharCodec = sqlCodecDefinitions.char.codec;
+const sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;
+const sqlIntCodec = sqlCodecDefinitions.int.codec;
+const sqlFloatCodec = sqlCodecDefinitions.float.codec;
+const sqlTextCodec = sqlCodecDefinitions.text.codec;
+const sqlTimestampCodec = sqlCodecDefinitions.timestamp.codec;
+const pgTextCodec = codec({
+	typeId: PG_TEXT_CODEC_ID,
+	targetTypes: ["text"],
+	traits: [
+		"equality",
+		"order",
+		"textual"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "text" } } } }
+});
+const pgCharCodec = aliasCodec(sqlCharCodec, {
+	typeId: PG_CHAR_CODEC_ID,
+	targetTypes: ["character"],
+	meta: { db: { sql: { postgres: { nativeType: "character" } } } }
+});
+const pgVarcharCodec = aliasCodec(sqlVarcharCodec, {
+	typeId: PG_VARCHAR_CODEC_ID,
+	targetTypes: ["character varying"],
+	meta: { db: { sql: { postgres: { nativeType: "character varying" } } } }
+});
+const pgIntCodec = aliasCodec(sqlIntCodec, {
+	typeId: PG_INT_CODEC_ID,
+	targetTypes: ["int4"],
+	meta: { db: { sql: { postgres: { nativeType: "integer" } } } }
+});
+const pgFloatCodec = aliasCodec(sqlFloatCodec, {
+	typeId: PG_FLOAT_CODEC_ID,
+	targetTypes: ["float8"],
+	meta: { db: { sql: { postgres: { nativeType: "double precision" } } } }
+});
+const pgInt4Codec = codec({
+	typeId: PG_INT4_CODEC_ID,
+	targetTypes: ["int4"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "integer" } } } }
+});
+const pgNumericCodec = codec({
+	typeId: PG_NUMERIC_CODEC_ID,
+	targetTypes: ["numeric", "decimal"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => {
+		if (typeof wire === "number") return String(wire);
+		return wire;
+	},
+	paramsSchema: numericParamsSchema,
+	renderOutputType: (typeParams) => {
+		const precision = typeParams["precision"];
+		if (precision === void 0) return void 0;
+		if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`);
+		const scale = typeParams["scale"];
+		return typeof scale === "number" ? `Numeric<${precision}, ${scale}>` : `Numeric<${precision}>`;
+	},
+	meta: { db: { sql: { postgres: { nativeType: "numeric" } } } }
+});
+const pgInt2Codec = codec({
+	typeId: PG_INT2_CODEC_ID,
+	targetTypes: ["int2"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "smallint" } } } }
+});
+const pgInt8Codec = codec({
+	typeId: PG_INT8_CODEC_ID,
+	targetTypes: ["int8"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "bigint" } } } }
+});
+const pgFloat4Codec = codec({
+	typeId: PG_FLOAT4_CODEC_ID,
+	targetTypes: ["float4"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "real" } } } }
+});
+const pgFloat8Codec = codec({
+	typeId: PG_FLOAT8_CODEC_ID,
+	targetTypes: ["float8"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "double precision" } } } }
+});
+const pgTimestampCodec = codec({
+	typeId: PG_TIMESTAMP_CODEC_ID,
+	targetTypes: ["timestamp"],
+	traits: ["equality", "order"],
+	encode: (value) => {
+		if (value instanceof Date) return value.toISOString();
+		if (typeof value === "string") return value;
+		return String(value);
+	},
+	decode: (wire) => {
+		if (wire instanceof Date) return wire.toISOString();
+		return wire;
+	},
+	encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
+	decodeJson: (json) => {
+		if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
+		const date = new Date(json);
+		if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+		return date;
+	},
+	paramsSchema: precisionParamsSchema,
+	renderOutputType: (typeParams) => renderPrecision("Timestamp", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "timestamp without time zone" } } } }
+});
+const pgTimestamptzCodec = codec({
+	typeId: PG_TIMESTAMPTZ_CODEC_ID,
+	targetTypes: ["timestamptz"],
+	traits: ["equality", "order"],
+	encode: (value) => {
+		if (value instanceof Date) return value.toISOString();
+		if (typeof value === "string") return value;
+		return String(value);
+	},
+	decode: (wire) => {
+		if (wire instanceof Date) return wire.toISOString();
+		return wire;
+	},
+	encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
+	decodeJson: (json) => {
+		if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
+		const date = new Date(json);
+		if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+		return date;
+	},
+	paramsSchema: precisionParamsSchema,
+	renderOutputType: (typeParams) => renderPrecision("Timestamptz", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "timestamp with time zone" } } } }
+});
+const pgTimeCodec = codec({
+	typeId: PG_TIME_CODEC_ID,
+	targetTypes: ["time"],
+	traits: ["equality", "order"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: precisionParamsSchema,
+	renderOutputType: (typeParams) => renderPrecision("Time", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "time" } } } }
+});
+const pgTimetzCodec = codec({
+	typeId: PG_TIMETZ_CODEC_ID,
+	targetTypes: ["timetz"],
+	traits: ["equality", "order"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: precisionParamsSchema,
+	renderOutputType: (typeParams) => renderPrecision("Timetz", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "timetz" } } } }
+});
+const pgBoolCodec = codec({
+	typeId: PG_BOOL_CODEC_ID,
+	targetTypes: ["bool"],
+	traits: ["equality", "boolean"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "boolean" } } } }
+});
+const pgBitCodec = codec({
+	typeId: PG_BIT_CODEC_ID,
+	targetTypes: ["bit"],
+	traits: ["equality", "order"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: lengthParamsSchema,
+	renderOutputType: (typeParams) => renderLength("Bit", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "bit" } } } }
+});
+const pgVarbitCodec = codec({
+	typeId: PG_VARBIT_CODEC_ID,
+	targetTypes: ["bit varying"],
+	traits: ["equality", "order"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: lengthParamsSchema,
+	renderOutputType: (typeParams) => renderLength("VarBit", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "bit varying" } } } }
+});
+const pgEnumCodec = codec({
+	typeId: PG_ENUM_CODEC_ID,
+	targetTypes: ["enum"],
+	traits: ["equality", "order"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	renderOutputType: (typeParams) => {
+		const values = typeParams["values"];
+		if (!Array.isArray(values)) throw new Error(`renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`);
+		return values.map((value) => `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(" | ");
+	}
+});
+const pgIntervalCodec = codec({
+	typeId: PG_INTERVAL_CODEC_ID,
+	targetTypes: ["interval"],
+	traits: ["equality", "order"],
+	encode: (value) => value,
+	decode: (wire) => {
+		if (typeof wire === "string") return wire;
+		return JSON.stringify(wire);
+	},
+	paramsSchema: precisionParamsSchema,
+	renderOutputType: (typeParams) => renderPrecision("Interval", typeParams),
+	meta: { db: { sql: { postgres: { nativeType: "interval" } } } }
+});
+const pgJsonCodec = codec({
+	typeId: PG_JSON_CODEC_ID,
+	targetTypes: ["json"],
+	traits: [],
+	encode: (value) => JSON.stringify(value),
+	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
+	renderOutputType: renderJsonOutputType,
+	meta: { db: { sql: { postgres: { nativeType: "json" } } } }
+});
+const pgJsonbCodec = codec({
+	typeId: PG_JSONB_CODEC_ID,
+	targetTypes: ["jsonb"],
+	traits: ["equality"],
+	encode: (value) => JSON.stringify(value),
+	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
+	renderOutputType: renderJsonOutputType,
+	meta: { db: { sql: { postgres: { nativeType: "jsonb" } } } }
+});
+const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec).add("sql-text", sqlTextCodec).add("sql-timestamp", sqlTimestampCodec).add("text", pgTextCodec).add("character", pgCharCodec).add("character varying", pgVarcharCodec).add("integer", pgIntCodec).add("double precision", pgFloatCodec).add("int4", pgInt4Codec).add("int2", pgInt2Codec).add("int8", pgInt8Codec).add("float4", pgFloat4Codec).add("float8", pgFloat8Codec).add("numeric", pgNumericCodec).add("timestamp", pgTimestampCodec).add("timestamptz", pgTimestamptzCodec).add("time", pgTimeCodec).add("timetz", pgTimetzCodec).add("bool", pgBoolCodec).add("bit", pgBitCodec).add("bit varying", pgVarbitCodec).add("interval", pgIntervalCodec).add("enum", pgEnumCodec).add("json", pgJsonCodec).add("jsonb", pgJsonbCodec);
+const codecDefinitions = codecs.codecDefinitions;
+const dataTypes = codecs.dataTypes;
+
+//#endregion
+export { dataTypes as n, codecDefinitions as t };
+//# sourceMappingURL=codecs-C3wlpdV7.mjs.map