effect-qb 0.15.0 → 0.16.0

package/dist/postgres/metadata.js

@@ -74,6 +74,7 @@ var makeColumnDefinition = (schema, metadata) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
     kind: "scalar",
@@ -93,6 +94,7 @@ var makeColumnDefinition = (schema, metadata) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -109,6 +111,7 @@ var remapColumnDefinition = (column, options = {}) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect
   };
@@ -127,6 +130,7 @@ var remapColumnDefinition = (column, options = {}) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -148,6 +152,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
     runtime: undefined,
     dbType: column.metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: column.metadata.driverValueMapping,
     nullability: column.metadata.nullable ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
     kind: "scalar",
@@ -711,6 +716,7 @@ var emptyContext = () => ({
   nullKeys: new Set,
   eqLiterals: new Map,
   neqLiterals: new Map,
+  literalSets: new Map,
   sourceNames: new Set,
   contradiction: false,
   unknown: false
@@ -720,6 +726,7 @@ var cloneContext = (context) => ({
   nullKeys: new Set(context.nullKeys),
   eqLiterals: new Map(context.eqLiterals),
   neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])),
+  literalSets: new Map(Array.from(context.literalSets.entries(), ([key, values]) => [key, new Set(values)])),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
@@ -753,7 +760,12 @@ var addEqLiteral = (context, key, value) => {
   if (neqValues?.has(value)) {
     context.contradiction = true;
   }
+  const existingSet = context.literalSets.get(key);
+  if (existingSet !== undefined && !existingSet.has(value)) {
+    context.contradiction = true;
+  }
   context.eqLiterals.set(key, value);
+  context.literalSets.set(key, new Set([value]));
 };
 var addNeqLiteral = (context, key, value) => {
   addNonNull(context, key);
@@ -764,6 +776,18 @@ var addNeqLiteral = (context, key, value) => {
   values.add(value);
   context.neqLiterals.set(key, values);
 };
+var addLiteralSet = (context, key, values) => {
+  addNonNull(context, key);
+  const existingEq = context.eqLiterals.get(key);
+  if (existingEq !== undefined && !values.has(existingEq)) {
+    context.contradiction = true;
+  }
+  const existing = context.literalSets.get(key);
+  context.literalSets.set(key, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
+  if (context.literalSets.get(key)?.size === 0) {
+    context.contradiction = true;
+  }
+};
 var applyEqColumn = (context, left, right) => {
   const leftValue = context.eqLiterals.get(left);
   const rightValue = context.eqLiterals.get(right);
@@ -803,6 +827,9 @@ var applyAtom = (context, atom) => {
     case "neq-literal":
       addNeqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addLiteralSet(context, atom.key, new Set(atom.values));
+      return;
     case "eq-column":
       applyEqColumn(context, atom.left, atom.right);
       return;
@@ -825,6 +852,9 @@ var applyNegativeAtom = (context, atom) => {
     case "neq-literal":
       addEqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addNonNull(context, atom.key);
+      return;
     case "eq-column":
       addNonNull(context, atom.left);
       addNonNull(context, atom.right);
@@ -857,6 +887,17 @@ var intersectNeqLiterals = (left, right) => {
   }
   return result;
 };
+var unionLiteralSets = (left, right) => {
+  const result = new Map;
+  for (const [key, leftValues] of left) {
+    const rightValues = right.get(key);
+    if (rightValues === undefined) {
+      continue;
+    }
+    result.set(key, new Set([...leftValues, ...rightValues]));
+  }
+  return result;
+};
 var intersectContexts = (left, right) => {
   if (left.contradiction) {
     return cloneContext(right);
@@ -869,6 +910,7 @@ var intersectContexts = (left, right) => {
     nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
+    literalSets: unionLiteralSets(left.literalSets, right.literalSets),
     sourceNames: new Set(Array.from(left.sourceNames).filter((name) => right.sourceNames.has(name))),
     contradiction: false,
     unknown: left.unknown || right.unknown
@@ -942,6 +984,45 @@ var columnKeyOfExpression = (value) => {
   const ast = astOf(value);
   return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined;
 };
+var sameDbType = (left, right) => left.dialect === right.dialect && left.kind === right.kind;
+var jsonPathPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  switch (ast.kind) {
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText": {
+      const jsonAst = ast;
+      const segments = jsonAst.segments;
+      if (segments.length === 0 || segments.length > 8) {
+        return;
+      }
+      const path = [];
+      for (const segment of segments) {
+        if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
+          return;
+        }
+        path.push(segment.key);
+      }
+      if (path.length === 0) {
+        return;
+      }
+      const baseKey = columnKeyOfExpression(jsonAst.base);
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path.join(".")}`;
+    }
+    default:
+      return;
+  }
+};
+var predicateKeyOfExpression = (value) => columnKeyOfExpression(value) ?? castPredicateKeyOfExpression(value) ?? jsonPathPredicateKeyOfExpression(value);
+var castPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  if (ast.kind !== "cast") {
+    return;
+  }
+  const source = ast.value;
+  return sameDbType(source[TypeId2].dbType, ast.target) ? predicateKeyOfExpression(source) : undefined;
+};
 var valueKeyOfLiteral = (value) => {
   if (typeof value === "string") {
     return `string:${value}`;
@@ -961,7 +1042,7 @@ var valueKeyOfLiteral = (value) => {
   return "unknown";
 };
 var nonNullFactsOfExpression = (value) => {
-  const key = columnKeyOfExpression(value);
+  const key = predicateKeyOfExpression(value);
   return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
 };
 var combineFacts = (left, right) => {
@@ -974,8 +1055,8 @@ var combineFacts = (left, right) => {
   return andFormula(left, right);
 };
 var formulaOfEq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -1022,8 +1103,8 @@ var formulaOfEq = (left, right) => {
   });
 };
 var formulaOfNeq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -1066,8 +1147,8 @@ var formulaOfNeq = (left, right) => {
   return combineFacts(nonNullFactsOfExpression(left), nonNullFactsOfExpression(right));
 };
 var formulaOfIsNotDistinctFrom = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -1173,11 +1254,11 @@ var formulaOfExpression = (value) => {
       }
       return unknownTag("literal:non-boolean");
     case "isNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
     }
     case "isNotNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
     }
     case "not":
@@ -1196,7 +1277,15 @@ var formulaOfExpression = (value) => {
       return anyFormula(ast.values.map((value2) => formulaOfExpression(value2)));
     case "in": {
       const [left, ...rest] = ast.values;
-      return left === undefined ? falseFormula() : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+      if (left === undefined) {
+        return falseFormula();
+      }
+      const key = predicateKeyOfExpression(left);
+      const literalValues = rest.map((entry) => {
+        const entryAst = astOf(entry);
+        return entryAst.kind === "literal" && entryAst.value !== null ? valueKeyOfLiteral(entryAst.value) : undefined;
+      });
+      return key !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
@@ -1264,6 +1353,7 @@ var makeExpression = (state, ast) => {
     runtime: state.runtime,
     dbType: state.dbType,
     runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
     nullability: state.nullability,
     dialect: state.dialect,
     kind: state.kind ?? "scalar",
@@ -1272,7 +1362,7 @@ var makeExpression = (state, ast) => {
   expression[TypeId3] = ast;
   return expression;
 };
-var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState) => {
+var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState, _facts) => {
   const plan = Object.create(PlanProto);
   Object.defineProperty(plan, "pipe", {
     configurable: true,
@@ -1288,6 +1378,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     availableNames: undefined,
     grouped: undefined,
     assumptions: _assumptions ?? trueFormula(),
+    facts: _facts ?? undefined,
     capabilities: undefined,
     statement: _statement ?? "select",
     target: _target ?? undefined,
@@ -1372,6 +1463,421 @@ var path = (...segments) => ({
   segments
 });
 
+// src/internal/runtime/driver-value-mapping.ts
+import * as Schema3 from "effect/Schema";
+
+// src/internal/runtime/normalize.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pad = (value, width = 2) => value.toString().padStart(width, "0");
+var formatLocalDate = (value) => `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
+var formatLocalTime = (value) => {
+  const milliseconds = value.getUTCMilliseconds();
+  const base = `${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
+};
+var formatLocalDateTime = (value) => {
+  const milliseconds = value.getUTCMilliseconds();
+  const base = `${formatLocalDate(value)}T${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
+};
+var runtimeTagOfBaseDbType = (dbType) => {
+  return dbType.runtime;
+};
+var expectString = (value, label) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new Error(`Expected ${label} as string`);
+};
+var normalizeNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  if (typeof value === "bigint" && Number.isSafeInteger(Number(value))) {
+    return Number(value);
+  }
+  throw new Error("Expected a finite numeric value");
+};
+var normalizeBoolean = (value) => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "t" || normalized === "1") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "f" || normalized === "0") {
+      return false;
+    }
+  }
+  throw new Error("Expected a boolean-like value");
+};
+var normalizeBigIntString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return BigInt(value).toString();
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+    return BigInt(value.trim()).toString();
+  }
+  throw new Error("Expected an integer-like bigint value");
+};
+var canonicalizeDecimalString = (input) => {
+  const trimmed = input.trim();
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed);
+  if (match === null) {
+    throw new Error("Expected a decimal string");
+  }
+  const sign = match[1] === "-" ? "-" : "";
+  const integer = match[2].replace(/^0+(?=\d)/, "") || "0";
+  const fraction = (match[3] ?? "").replace(/0+$/, "");
+  if (fraction.length === 0) {
+    return `${sign}${integer}`;
+  }
+  return `${sign}${integer}.${fraction}`;
+};
+var normalizeDecimalString = (value) => {
+  if (typeof value === "string") {
+    return canonicalizeDecimalString(value);
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const rendered = String(value);
+    if (/[eE]/.test(rendered)) {
+      throw new Error("Scientific notation is not a supported decimal runtime");
+    }
+    return canonicalizeDecimalString(rendered);
+  }
+  throw new Error("Expected a decimal-like value");
+};
+var normalizeLocalDate = (value) => {
+  if (value instanceof Date) {
+    return formatLocalDate(value);
+  }
+  const raw = expectString(value, "local date").trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+    return raw;
+  }
+  const parsed = new Date(raw);
+  if (!Number.isNaN(parsed.getTime())) {
+    return formatLocalDate(parsed);
+  }
+  throw new Error("Expected a local-date value");
+};
+var normalizeLocalTime = (value) => {
+  if (value instanceof Date) {
+    return formatLocalTime(value);
+  }
+  const raw = expectString(value, "local time").trim();
+  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected a local-time value");
+};
+var normalizeOffsetTime = (value) => {
+  if (value instanceof Date) {
+    return `${formatLocalTime(value)}Z`;
+  }
+  const raw = expectString(value, "offset time").trim();
+  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected an offset-time value");
+};
+var normalizeLocalDateTime = (value) => {
+  if (value instanceof Date) {
+    return formatLocalDateTime(value);
+  }
+  const raw = expectString(value, "local datetime").trim();
+  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+    return raw.replace(" ", "T");
+  }
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
+    const parsed = new Date(raw);
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDateTime(parsed);
+    }
+  }
+  throw new Error("Expected a local-datetime value");
+};
+var normalizeInstant = (value) => {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  const raw = expectString(value, "instant").trim();
+  if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
+    throw new Error("Instant values require a timezone offset");
+  }
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error("Expected an ISO instant value");
+  }
+  return parsed.toISOString();
+};
+var normalizeYear = (value) => {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 9999) {
+    return pad(value, 4);
+  }
+  const raw = expectString(value, "year").trim();
+  if (/^\d{4}$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected a four-digit year");
+};
+var normalizeBytes = (value) => {
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value);
+  }
+  const BufferConstructor = globalThis.Buffer;
+  if (BufferConstructor !== undefined && value instanceof BufferConstructor) {
+    return new Uint8Array(value);
+  }
+  throw new Error("Expected a byte array value");
+};
+var isJsonValue = (value) => {
+  if (value === null) {
+    return true;
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return true;
+    case "object":
+      if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+      }
+      return isRecord(value) && Object.values(value).every(isJsonValue);
+    default:
+      return false;
+  }
+};
+var normalizeJson = (value) => {
+  if (typeof value === "string") {
+    const parsed = JSON.parse(value);
+    if (isJsonValue(parsed)) {
+      return parsed;
+    }
+    throw new Error("Parsed JSON value is not a valid JSON runtime");
+  }
+  if (isJsonValue(value)) {
+    return value;
+  }
+  throw new Error("Expected a JSON value");
+};
+var normalizeDbValue = (dbType, value) => {
+  if (value === null) {
+    return null;
+  }
+  if ("base" in dbType) {
+    return normalizeDbValue(dbType.base, value);
+  }
+  if ("element" in dbType) {
+    if (!Array.isArray(value)) {
+      throw new Error("Expected an array value");
+    }
+    return value.map((entry) => normalizeDbValue(dbType.element, entry));
+  }
+  if ("fields" in dbType) {
+    if (!isRecord(value)) {
+      throw new Error("Expected a record value");
+    }
+    const normalized = {};
+    for (const [key2, fieldDbType] of Object.entries(dbType.fields)) {
+      if (key2 in value) {
+        normalized[key2] = normalizeDbValue(fieldDbType, value[key2]);
+      }
+    }
+    return normalized;
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return normalizeJson(value);
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return expectString(value, "text");
+  }
+  switch (runtimeTagOfBaseDbType(dbType)) {
+    case "string":
+      return expectString(value, "text");
+    case "number":
+      return normalizeNumber(value);
+    case "bigintString":
+      return normalizeBigIntString(value);
+    case "boolean":
+      return normalizeBoolean(value);
+    case "json":
+      return normalizeJson(value);
+    case "localDate":
+      return normalizeLocalDate(value);
+    case "localTime":
+      return normalizeLocalTime(value);
+    case "offsetTime":
+      return normalizeOffsetTime(value);
+    case "localDateTime":
+      return normalizeLocalDateTime(value);
+    case "instant":
+      return normalizeInstant(value);
+    case "year":
+      return normalizeYear(value);
+    case "decimalString":
+      return normalizeDecimalString(value);
+    case "bytes":
+      return normalizeBytes(value);
+    case "array":
+      if (!Array.isArray(value)) {
+        throw new Error("Expected an array value");
+      }
+      return value;
+    case "record":
+      if (!isRecord(value)) {
+        throw new Error("Expected a record value");
+      }
+      return value;
+    case "null":
+      return null;
+    case "unknown":
+    case undefined:
+      return value;
+  }
+};
+
+// src/internal/runtime/driver-value-mapping.ts
+var runtimeTagOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return runtimeTagOfDbType(dbType.base);
+  }
+  if ("element" in dbType) {
+    return "array";
+  }
+  if ("fields" in dbType) {
+    return "record";
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return "json";
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return "string";
+  }
+  return dbType.runtime;
+};
+var familyOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return familyOfDbType(dbType.base);
+  }
+  return dbType.family;
+};
+var mappingCandidates = (context) => {
+  const dbType = context.dbType;
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  const family = familyOfDbType(dbType);
+  return [
+    context.driverValueMapping,
+    dbType?.driverValueMapping,
+    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
+    family === undefined ? undefined : context.valueMappings?.[family],
+    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
+  ];
+};
+var findMapping = (context, key2) => {
+  for (const candidate of mappingCandidates(context)) {
+    const value = candidate?.[key2];
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return;
+};
+var encodeWithSchema = (schema2, value) => {
+  if (schema2 === undefined) {
+    return { value, encoded: false };
+  }
+  if (!Schema3.is(schema2)(value)) {
+    return { value, encoded: false };
+  }
+  return {
+    value: Schema3.encodeUnknownSync(schema2)(value),
+    encoded: true
+  };
+};
+var toDriverValue = (value, context) => {
+  if (value === null) {
+    return null;
+  }
+  const dbType = context.dbType;
+  const encoded = encodeWithSchema(context.runtimeSchema, value);
+  let current = encoded.value;
+  const custom = findMapping(context, "toDriver");
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(current, dbType);
+  }
+  return dbType === undefined || !encoded.encoded ? current : normalizeDbValue(dbType, current);
+};
+var fromDriverValue = (value, context) => {
+  if (value === null) {
+    return null;
+  }
+  const dbType = context.dbType;
+  const custom = findMapping(context, "fromDriver");
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(value, dbType);
+  }
+  return dbType === undefined ? value : normalizeDbValue(dbType, value);
+};
+var textCast = (sql) => `(${sql})::text`;
+var postgresJsonSql = (sql, dbType) => {
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  switch (runtimeTag) {
+    case "bigintString":
+    case "decimalString":
+    case "localDate":
+    case "localTime":
+    case "offsetTime":
+    case "localDateTime":
+    case "instant":
+    case "year":
+      return textCast(sql);
+    case "bytes":
+      return `encode(${sql}, 'base64')`;
+    default:
+      return sql;
+  }
+};
+var renderSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom = findMapping(context, "selectSql");
+  return custom !== undefined && dbType !== undefined ? custom(sql, dbType) : sql;
+};
+var renderJsonSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom = findMapping(context, "jsonSelectSql");
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(sql, dbType);
+  }
+  return context.dialect === "postgres" && dbType !== undefined ? postgresJsonSql(sql, dbType) : sql;
+};
+
 // src/internal/projection-alias.ts
 var TypeId8 = Symbol.for("effect-qb/ProjectionAlias");
 
@@ -1714,8 +2220,27 @@ var renderPostgresJsonValue = (value, state, dialect) => {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression(value, state, dialect);
+  const ast = value[TypeId3];
+  if (ast.kind === "literal") {
+    return `cast(${rendered} as jsonb)`;
+  }
   return value[TypeId2].dbType.kind === "jsonb" ? rendered : `cast(${rendered} as jsonb)`;
 };
+var expressionDriverContext = (expression, state, dialect) => ({
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: expression[TypeId2].dbType,
+  runtimeSchema: expression[TypeId2].runtimeSchema,
+  driverValueMapping: expression[TypeId2].driverValueMapping
+});
+var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
+var encodeArrayValues = (values, column, state, dialect) => values.map((value) => toDriverValue(value, {
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: column.metadata.dbType,
+  runtimeSchema: column.schema,
+  driverValueMapping: column.metadata.driverValueMapping
+}));
 var renderPostgresJsonKind = (value) => value[TypeId2].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue(value)) {
@@ -1844,7 +2369,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       const entries = Array.isArray(ast.entries) ? ast.entries : [];
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
-        renderExpression(entry.value, state, dialect)
+        renderJsonInputExpression(entry.value, state, dialect)
       ]);
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`;
@@ -1856,7 +2381,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonBuildArray": {
       const values = Array.isArray(ast.values) ? ast.values : [];
-      const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ");
+      const renderedValues = values.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
@@ -1870,7 +2395,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_json(${renderExpression(base, state, dialect)})`;
+        return `to_json(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`;
@@ -1881,7 +2406,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_jsonb(${renderExpression(base, state, dialect)})`;
+        return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`;
@@ -2068,7 +2593,7 @@ var renderSelectionList = (selection, state, dialect, validateAggregation) => {
   }
   const flattened = flattenSelection(selection);
   const projections = selectionProjections(selection);
-  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderExpression(expression, state, dialect)} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
+  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
   return {
     sql,
     projections
@@ -2148,11 +2673,11 @@ var renderQueryAst = (ast, state, dialect) => {
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields = table[TypeId4].fields;
-          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(entry.values, state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
+          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = unnestSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state)).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -2413,7 +2938,7 @@ var renderExpression = (expression, state, dialect) => {
     case "column":
       return ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
     case "literal":
-      return dialect.renderLiteral(ast.value, state);
+      return dialect.renderLiteral(ast.value, state, expression[TypeId2]);
     case "excluded":
       return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
     case "cast":
@@ -2555,14 +3080,19 @@ import { parse as parse2, toSql as toSql2 } from "pgsql-ast-parser";
 
 // src/postgres/internal/dialect.ts
 var quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
-var renderLiteral = (value, state) => {
-  if (value === null) {
+var renderLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "postgres",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
     return "null";
   }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false";
   }
-  state.params.push(value);
+  state.params.push(driverValue);
   return `$${state.params.length}`;
 };
 var postgresDialect = {
@@ -2652,7 +3182,7 @@ var normalizeDdlExpressionSql = (expression) => {
 };
 
 // src/postgres/schema-management.ts
-import * as Schema3 from "effect/Schema";
+import * as Schema4 from "effect/Schema";
 import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
 var EnumTypeId = Symbol.for("effect-qb/SchemaManagement/Enum");
 var SequenceTypeId = Symbol.for("effect-qb/SchemaManagement/Sequence");
@@ -2671,8 +3201,8 @@ var EnumProto = {
     };
   },
   column() {
-    const values = this.values.map((value) => Schema3.Literal(value));
-    return makeColumnDefinition(values.length === 1 ? values[0] : Schema3.Union(...values), {
+    const values = this.values.map((value) => Schema4.Literal(value));
+    return makeColumnDefinition(values.length === 1 ? values[0] : Schema4.Union(...values), {
       dbType: this.type(),
       nullable: false,
       hasDefault: false,