effect-qb 0.17.0 → 4.0.0-beta.66

package/dist/postgres.js

@@ -347,12 +347,7 @@ var validateOptions = (tableName, fields, options) => {
 };
 
 // src/internal/schema-derivation.ts
-import * as VariantSchema from "@effect/experimental/VariantSchema";
 import * as Schema2 from "effect/Schema";
-var TableSchema = VariantSchema.make({
-  variants: ["select", "insert", "update"],
-  defaultVariant: "select"
-});
 var maybeBrandSchema = (column, tableName, columnName) => column.metadata.brand === true ? Schema2.brand(`${tableName}.${columnName}`)(column.schema) : column.schema;
 var selectSchema = (column, tableName, columnName) => column.metadata.nullable ? Schema2.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
 var insertSchema = (column, tableName, columnName) => {
@@ -369,42 +364,37 @@ var updateSchema = (column, tableName, columnName, isPrimaryKey) => {
   const base = column.metadata.nullable ? Schema2.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
   return Schema2.optional(base);
 };
-var deriveSchemas = (tableName, fields, primaryKeyColumns) => {
+var fieldSchemaForVariant = (variant, column, tableName, columnName, primaryKeySet) => {
+  switch (variant) {
+    case "select":
+      return selectSchema(column, tableName, columnName);
+    case "insert":
+      return insertSchema(column, tableName, columnName);
+    case "update":
+      return updateSchema(column, tableName, columnName, primaryKeySet.has(columnName));
+  }
+};
+var deriveSchema = (variant, tableName, fields, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
-  const variants = {};
+  const structFields = {};
   for (const [key, column] of Object.entries(fields)) {
-    const config = {
-      select: selectSchema(column, tableName, key),
-      insert: undefined,
-      update: undefined
-    };
-    const insert = insertSchema(column, tableName, key);
-    const update = updateSchema(column, tableName, key, primaryKeySet.has(key));
-    if (insert !== undefined) {
-      config.insert = insert;
-    } else {
-      delete config.insert;
-    }
-    if (update !== undefined) {
-      config.update = update;
-    } else {
-      delete config.update;
+    const schema = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+    if (schema !== undefined) {
+      structFields[key] = schema;
     }
-    variants[key] = TableSchema.Field(config);
   }
-  const struct = TableSchema.Struct(variants);
-  return {
-    select: TableSchema.extract(struct, "select"),
-    insert: TableSchema.extract(struct, "insert"),
-    update: TableSchema.extract(struct, "update")
-  };
+  return Schema2.Struct(structFields);
 };
+var deriveSelectSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("select", tableName, fields, primaryKeyColumns);
+var deriveInsertSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("insert", tableName, fields, primaryKeyColumns);
+var deriveUpdateSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("update", tableName, fields, primaryKeyColumns);
 
 // src/internal/table.ts
 var TypeId4 = Symbol.for("effect-qb/Table");
 var OptionsSymbol = Symbol.for("effect-qb/Table/normalizedOptions");
 var options = Symbol.for("effect-qb/Table/declaredOptions");
 var CacheSymbol = Symbol.for("effect-qb/Table/cache");
+var SchemaCacheSymbol = Symbol.for("effect-qb/Table/schemaCache");
 var DeclaredOptionsSymbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions");
 var TableProto = {
   pipe() {
@@ -427,14 +417,86 @@ var buildArtifacts = (name, fields, declaredOptions, schemaName) => {
   validateOptions(name, fields, declaredOptions);
   const primaryKey = resolvePrimaryKeyColumns(fields, declaredOptions);
   const columns = Object.fromEntries(Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)]));
-  const schemas = deriveSchemas(name, fields, primaryKey);
   return {
     columns,
-    schemas,
     normalizedOptions,
     primaryKey
   };
 };
+var getSchemaCache = (table) => {
+  const target = table;
+  if (target[SchemaCacheSymbol] !== undefined) {
+    return target[SchemaCacheSymbol];
+  }
+  const cache = {};
+  Object.defineProperty(table, SchemaCacheSymbol, {
+    configurable: true,
+    value: cache
+  });
+  return cache;
+};
+var deriveTableSchema = (table, variant) => {
+  const state = table[TypeId4];
+  switch (variant) {
+    case "select":
+      return deriveSelectSchema(state.name, state.fields, state.primaryKey);
+    case "insert":
+      return deriveInsertSchema(state.name, state.fields, state.primaryKey);
+    case "update":
+      return deriveUpdateSchema(state.name, state.fields, state.primaryKey);
+  }
+};
+var schemaFor = (table, variant) => {
+  const cache = getSchemaCache(table);
+  const cached = cache[variant];
+  if (cached !== undefined) {
+    return cached;
+  }
+  const schema = deriveTableSchema(table, variant);
+  cache[variant] = schema;
+  return schema;
+};
+function selectSchema2(table) {
+  return schemaFor(table, "select");
+}
+function insertSchema2(table) {
+  return schemaFor(table, "insert");
+}
+function updateSchema2(table) {
+  return schemaFor(table, "update");
+}
+var schemasFor = (table) => {
+  const cache = getSchemaCache(table);
+  if (cache.schemas !== undefined) {
+    return cache.schemas;
+  }
+  const schemas = {};
+  Object.defineProperties(schemas, {
+    select: {
+      enumerable: true,
+      get: () => selectSchema2(table)
+    },
+    insert: {
+      enumerable: true,
+      get: () => insertSchema2(table)
+    },
+    update: {
+      enumerable: true,
+      get: () => updateSchema2(table)
+    }
+  });
+  cache.schemas = schemas;
+  return schemas;
+};
+var defineSchemasGetter = (table) => {
+  Object.defineProperty(table, "schemas", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return schemasFor(table);
+    }
+  });
+};
 var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema", schemaName, schemaMode = "default") => {
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
   const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName);
@@ -442,7 +504,7 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   const table = attachPipe2(Object.create(TableProto));
   table.name = name;
   table.columns = artifacts.columns;
-  table.schemas = artifacts.schemas;
+  defineSchemasGetter(table);
   table[TypeId4] = {
     name,
     baseName,
@@ -515,7 +577,6 @@ var ensureClassArtifacts = (self) => {
   const table = applyDeclaredOptions(makeTable(state.name, state.fields, [], state.name, "schema", state.schemaName, state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"), classOptions);
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
     primaryKey: table[TypeId4].primaryKey
   };
@@ -538,7 +599,7 @@ var makeOption = (option) => {
   return builder;
 };
 var option = (spec) => makeOption(spec);
-function make2(name, fields, schemaName) {
+function make(name, fields, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
@@ -555,7 +616,7 @@ var alias = (table, aliasName) => {
   const aliased = attachPipe2(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey);
+  defineSchemasGetter(aliased);
   aliased[TypeId4] = {
     name: aliasName,
     baseName: state.baseName,
@@ -596,7 +657,7 @@ function Class(name, schemaName) {
         return ensureClassArtifacts(this).columns;
       }
       static get schemas() {
-        return ensureClassArtifacts(this).schemas;
+        return schemasFor(this);
       }
       static get [TypeId4]() {
         const declaredOptions = extractDeclaredOptions(this[options]);
@@ -2684,7 +2745,7 @@ import * as Schema4 from "effect/Schema";
 
 // src/internal/runtime/value.ts
 import * as Schema3 from "effect/Schema";
-var brandString = (pattern2, brand4) => Schema3.String.pipe(Schema3.pattern(pattern2), Schema3.brand(brand4));
+var brandString = (pattern, brand4) => Schema3.String.pipe(Schema3.check(Schema3.isPattern(pattern)), Schema3.brand(brand4));
 var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
 var isValidLocalDateString = (value) => {
   const match = localDatePattern.exec(value);
@@ -2737,11 +2798,11 @@ var isValidInstantString = (value) => {
   const match = instantPattern.exec(value);
   return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]) && isValidOffset(match[3]);
 };
-var LocalDateStringSchema = Schema3.String.pipe(Schema3.pattern(localDatePattern), Schema3.filter(isValidLocalDateString), Schema3.brand("LocalDateString"));
-var LocalTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localTimePattern), Schema3.filter(isValidLocalTimeString), Schema3.brand("LocalTimeString"));
-var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.pattern(offsetTimePattern), Schema3.filter(isValidOffsetTimeString), Schema3.brand("OffsetTimeString"));
-var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localDateTimePattern), Schema3.filter(isValidLocalDateTimeString), Schema3.brand("LocalDateTimeString"));
-var InstantStringSchema = Schema3.String.pipe(Schema3.pattern(instantPattern), Schema3.filter(isValidInstantString), Schema3.brand("InstantString"));
+var LocalDateStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDatePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateString(value))), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalTimeString(value))), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(offsetTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidOffsetTimeString(value))), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDateTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateTimeString(value))), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(instantPattern)), Schema3.check(Schema3.makeFilter((value) => isValidInstantString(value))), Schema3.brand("InstantString"));
 var YearStringSchema = brandString(/^\d{4}$/, "YearString");
 var canonicalizeBigIntString = (input) => {
   const trimmed = input.trim();
@@ -2781,13 +2842,22 @@ var isCanonicalDecimalString = (value) => {
     return false;
   }
 };
-var BigIntStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalBigIntString), Schema3.brand("BigIntString"));
-var DecimalStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalDecimalString), Schema3.brand("DecimalString"));
-var JsonValueSchema = Schema3.suspend(() => Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null, Schema3.Array(JsonValueSchema), Schema3.Record({
-  key: Schema3.String,
-  value: JsonValueSchema
-})));
-var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null);
+var BigIntStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalBigIntString(value))), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalDecimalString(value))), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null,
+  Schema3.Array(JsonValueSchema),
+  Schema3.Record(Schema3.String, JsonValueSchema)
+]));
+var JsonPrimitiveSchema = Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null
+]);
 
 // src/internal/runtime/normalize.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4995,8 +5065,7 @@ var EnumProto = {
     };
   },
   column() {
-    const values = this.values.map((value) => Schema6.Literal(value));
-    return makeColumnDefinition(values.length === 1 ? values[0] : Schema6.Union(...values), {
+    return makeColumnDefinition(Schema6.Literals(this.values), {
       dbType: this.type(),
       nullable: false,
       hasDefault: false,
@@ -5634,8 +5703,8 @@ var renderNumericDdlType = (kind, options2) => {
   }
   return options2.scale === undefined ? `${kind}(${options2.precision})` : `${kind}(${options2.precision},${options2.scale})`;
 };
-var boundedString = (length) => length === undefined ? Schema8.String : Schema8.String.pipe(Schema8.maxLength(length));
-var finiteNumber = Schema8.Number.pipe(Schema8.finite());
+var boundedString = (length) => length === undefined ? Schema8.String : Schema8.String.check(Schema8.isMaxLength(length));
+var finiteNumber = Schema8.Number.check(Schema8.isFinite());
 var custom = (schema3, dbType) => makeColumnDefinition(schema3, {
   dbType: enrichDbType(dbType),
   nullable: false,
@@ -5647,7 +5716,7 @@ var custom = (schema3, dbType) => makeColumnDefinition(schema3, {
   ddlType: undefined,
   identity: undefined
 });
-var uuid = () => primitive(Schema8.UUID, postgresDatatypes.uuid());
+var uuid = () => primitive(Schema8.String.check(Schema8.isUUID()), postgresDatatypes.uuid());
 var text = () => primitive(Schema8.String, postgresDatatypes.text());
 var int = () => primitive(Schema8.Int, postgresDatatypes.int4());
 var int2 = () => primitive(Schema8.Int, postgresDatatypes.int2());
@@ -5672,7 +5741,7 @@ var time = () => primitive(LocalTimeStringSchema, postgresDatatypes.time());
 var timetz = () => primitive(OffsetTimeStringSchema, postgresDatatypes.timetz());
 var timestamptz = () => primitive(InstantStringSchema, postgresDatatypes.timestamptz());
 var interval = () => primitive(Schema8.String, postgresDatatypes.interval());
-var bytea = () => primitive(Schema8.Uint8ArrayFromSelf, postgresDatatypes.bytea());
+var bytea = () => primitive(Schema8.Uint8Array, postgresDatatypes.bytea());
 var name = () => primitive(Schema8.String, postgresDatatypes.name());
 var oid = () => primitive(Schema8.Int, postgresDatatypes.oid());
 var regclass = () => primitive(Schema8.String, postgresDatatypes.regclass());
@@ -11131,27 +11200,28 @@ var exports_executor = {};
 __export(exports_executor, {
   withTransaction: () => withTransaction2,
   withSavepoint: () => withSavepoint2,
-  make: () => make6,
+  make: () => make5,
   driver: () => driver2,
   custom: () => custom3
 });
 import * as Effect2 from "effect/Effect";
-import * as SqlClient3 from "@effect/sql/SqlClient";
+import * as SqlClient3 from "effect/unstable/sql/SqlClient";
 import * as Stream2 from "effect/Stream";
 
 // src/internal/executor.ts
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
 import * as Schema11 from "effect/Schema";
-import * as SqlClient from "@effect/sql/SqlClient";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
 // src/internal/runtime/schema.ts
 import * as Schema10 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
-var FiniteNumberSchema = Schema10.Number.pipe(Schema10.finite());
+var FiniteNumberSchema = Schema10.Number.check(Schema10.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
@@ -11179,14 +11249,11 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema10.Uint8ArrayFromSelf;
+      return Schema10.Uint8Array;
     case "array":
       return Schema10.Array(Schema10.Unknown);
     case "record":
-      return Schema10.Record({
-        key: Schema10.String,
-        value: Schema10.Unknown
-      });
+      return Schema10.Record(Schema10.String, Schema10.Unknown);
     case "null":
       return Schema10.Null;
     case "unknown":
@@ -11224,22 +11291,18 @@ var unionAst = (asts) => {
   if (asts.length === 1) {
     return asts[0];
   }
-  return SchemaAST.Union.make(asts);
+  return new SchemaAST.Union(asts, "anyOf");
 };
 var propertyAstOf = (ast, key2) => {
   switch (ast._tag) {
-    case "Transformation":
-      return propertyAstOf(SchemaAST.typeAST(ast), key2);
-    case "Refinement":
-      return propertyAstOf(ast.from, key2);
     case "Suspend":
-      return propertyAstOf(ast.f(), key2);
-    case "TypeLiteral": {
+      return propertyAstOf(ast.thunk(), key2);
+    case "Objects": {
       const property = ast.propertySignatures.find((entry) => entry.name === key2);
       if (property !== undefined) {
         return property.type;
       }
-      const index5 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
+      const index5 = ast.indexSignatures.find((entry) => entry.parameter._tag === "String");
       return index5?.type;
     }
     case "Union": {
@@ -11255,21 +11318,17 @@ var propertyAstOf = (ast, key2) => {
 };
 var numberAstOf = (ast, index5) => {
   switch (ast._tag) {
-    case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index5);
-    case "Refinement":
-      return numberAstOf(ast.from, index5);
     case "Suspend":
-      return numberAstOf(ast.f(), index5);
-    case "TupleType": {
+      return numberAstOf(ast.thunk(), index5);
+    case "Arrays": {
       const element = ast.elements[index5];
       if (element !== undefined) {
-        return element.type;
+        return element;
       }
       if (ast.rest.length === 0) {
         return;
       }
-      return unionAst(ast.rest.map((entry) => entry.type));
+      return unionAst(ast.rest);
     }
     case "Union": {
       const values2 = ast.types.flatMap((member) => {
@@ -11284,7 +11343,7 @@ var numberAstOf = (ast, index5) => {
 };
 var exactJsonSegments = (segments) => segments.every((segment) => segment.kind === "key" || segment.kind === "index");
 var schemaAstAtExactJsonPath = (schema4, segments) => {
-  let current = SchemaAST.typeAST(schema4.ast);
+  let current = schema4.ast;
   for (const segment of segments) {
     if (segment.kind === "key") {
       const property = propertyAstOf(current, segment.key);
@@ -11314,28 +11373,28 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema10.Union(...resolved);
+  return Schema10.Union(resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
   return flattenSelection(selection)[0]?.expression;
 };
 var isJsonCompatibleAst = (ast) => {
+  ast = SchemaAST.toType(ast);
   switch (ast._tag) {
-    case "StringKeyword":
-    case "NumberKeyword":
-    case "BooleanKeyword":
-    case "TupleType":
-    case "TypeLiteral":
+    case "String":
+    case "Number":
+    case "Boolean":
+    case "Null":
+    case "Arrays":
+    case "Objects":
       return true;
     case "Literal":
-      return ast.literal === null || typeof ast.literal === "string" || typeof ast.literal === "number" || typeof ast.literal === "boolean";
+      return typeof ast.literal === "string" || typeof ast.literal === "number" || typeof ast.literal === "boolean";
     case "Union":
       return ast.types.every(isJsonCompatibleAst);
-    case "Transformation":
-      return isJsonCompatibleAst(SchemaAST.typeAST(ast));
     case "Suspend":
-      return isJsonCompatibleAst(ast.f());
+      return isJsonCompatibleAst(ast.thunk());
     default:
       return false;
   }
@@ -11344,14 +11403,14 @@ var jsonCompatibleSchema = (schema4) => {
   if (schema4 === undefined) {
     return;
   }
-  const ast = SchemaAST.typeAST(schema4.ast);
+  const ast = SchemaAST.toType(schema4.ast);
   return isJsonCompatibleAst(ast) ? schema4 : JsonValueSchema;
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
   return Schema10.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema10.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values2, context) => Schema10.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -11548,24 +11607,31 @@ var hasWriteCapability = (plan) => {
   }
   return false;
 };
-var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => ({
-  _tag: "RowDecodeError",
-  message: stage === "normalize" ? `Failed to normalize projection '${projection.alias}'` : `Failed to decode projection '${projection.alias}' against its runtime schema`,
-  dialect: rendered.dialect,
-  query: {
-    sql: rendered.sql,
-    params: rendered.params
-  },
-  projection: {
-    alias: projection.alias,
-    path: projection.path
-  },
-  dbType: expression[TypeId2].dbType,
-  raw,
-  normalized,
-  stage,
-  cause
-});
+var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
+  const schemaError = Schema11.isSchemaError(cause) ? {
+    message: cause.message,
+    issue: cause.issue
+  } : undefined;
+  return {
+    _tag: "RowDecodeError",
+    message: stage === "normalize" ? `Failed to normalize projection '${projection.alias}'` : `Failed to decode projection '${projection.alias}' against its runtime schema`,
+    dialect: rendered.dialect,
+    query: {
+      sql: rendered.sql,
+      params: rendered.params
+    },
+    projection: {
+      alias: projection.alias,
+      path: projection.path
+    },
+    dbType: expression[TypeId2].dbType,
+    raw,
+    normalized,
+    stage,
+    cause,
+    ...schemaError === undefined ? {} : { schemaError }
+  };
+};
 var hasOptionalSourceDependency = (expression, scope) => {
   const state = expression[TypeId2];
   return Object.keys(state.dependencies).some((sourceName) => !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional");
@@ -11608,8 +11674,8 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
         driverValueMapping: expression[TypeId2].driverValueMapping,
         valueMappings
       });
-    } catch (cause) {
-      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause);
+    } catch (cause2) {
+      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause2);
     }
   }
   const nullability = effectiveRuntimeNullability(expression, scope);
@@ -11635,11 +11701,15 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (Schema11.is(schema4)(normalized)) {
     return normalized;
   }
-  try {
-    return Schema11.decodeUnknownSync(schema4)(normalized);
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
+  const decoded = Schema11.decodeUnknownExit(schema4)(normalized);
+  if (Exit.isSuccess(decoded)) {
+    return decoded.value;
   }
+  const cause = Option.match(Exit.findErrorOption(decoded), {
+    onNone: () => decoded.cause,
+    onSome: (schemaError) => schemaError
+  });
+  throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
 };
 var makeRowDecoder = (rendered, plan, options2 = {}) => {
   const projections = flattenSelection(getAst(plan).select);
@@ -11662,15 +11732,11 @@ var makeRowDecoder = (rendered, plan, options2 = {}) => {
     return decoded;
   };
 };
-var decodeChunk = (rendered, plan, rows, options2 = {}) => {
-  const decodeRow = makeRowDecoder(rendered, plan, options2);
-  return Chunk.unsafeFromArray(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)));
-};
 var decodeRows = (rendered, plan, rows, options2 = {}) => {
   const decodeRow = makeRowDecoder(rendered, plan, options2);
   return rows.map((row) => decodeRow(row));
 };
-var make4 = (dialect, execute) => ({
+var make3 = (dialect, execute) => ({
   dialect,
   execute(plan) {
     return execute(plan);
@@ -11693,7 +11759,7 @@ function driver(dialect, executeOrHandlers) {
     }
   };
 }
-var streamFromSqlClient = (query) => Stream.unwrapScoped(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(SqlClient.TransactionConnection), Option.match({
+var streamFromSqlClient = (query) => Stream.unwrap(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(sql.transactionService), Option.match({
   onNone: () => sql.reserve,
   onSome: ([connection]) => Effect.succeed(connection)
 })).pipe(Effect.map((connection) => connection.executeStream(query.sql, [...query.params], undefined)))));
@@ -11719,7 +11785,7 @@ var validateProjectionPathsMatchSelection = (plan, projections) => {
     }
   }
 };
-function make5(dialect, render2) {
+function make4(dialect, render2) {
   if (typeof render2 !== "function") {
     throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
   }
@@ -11795,8 +11861,8 @@ var fromDriver = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
   },
   stream(plan) {
     const rendered = renderer.render(plan);
-    return Stream2.mapError(Stream2.mapChunksEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
-      try: () => decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+    return Stream2.mapError(Stream2.mapArrayEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
+      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -11811,13 +11877,13 @@ var sqlClientDriver = () => driver2({
   execute: (query) => Effect2.flatMap(SqlClient3.SqlClient, (sql) => sql.unsafe(query.sql, [...query.params])),
   stream: (query) => streamFromSqlClient(query)
 });
-function make6(options2 = {}) {
+function make5(options2 = {}) {
   if (options2.driver) {
-    return fromDriver(options2.renderer ?? make5("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
+    return fromDriver(options2.renderer ?? make4("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
   }
-  return fromDriver(options2.renderer ?? make5("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
+  return fromDriver(options2.renderer ?? make4("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
-var custom3 = (execute) => make4("postgres", execute);
+var custom3 = (execute) => make3("postgres", execute);
 // src/postgres/query.ts
 var exports_query2 = {};
 __export(exports_query2, {
@@ -11930,15 +11996,18 @@ __export(exports_schema_expression2, {
 // src/postgres/table.ts
 var exports_table2 = {};
 __export(exports_table2, {
+  updateSchema: () => updateSchema3,
   unique: () => unique4,
+  selectSchema: () => selectSchema3,
   schema: () => schema4,
   primaryKey: () => primaryKey4,
   options: () => options2,
   option: () => option2,
-  make: () => make7,
+  make: () => make6,
+  insertSchema: () => insertSchema3,
   index: () => index5,
   foreignKey: () => foreignKey4,
-  check: () => check2,
+  check: () => check3,
   alias: () => alias2,
   TypeId: () => TypeId10,
   OptionsSymbol: () => OptionsSymbol2,
@@ -11947,7 +12016,7 @@ __export(exports_table2, {
 var TypeId10 = TypeId4;
 var OptionsSymbol2 = OptionsSymbol;
 var options2 = options;
-var make7 = (name2, fields2, schemaName = "public") => make2(name2, fields2, schemaName);
+var make6 = (name2, fields2, schemaName = "public") => make(name2, fields2, schemaName);
 var schema4 = (schemaName) => {
   const table = (name2, fields2, ...declaredOptions) => schema(schemaName).table(name2, fields2, ...declaredOptions);
   return {
@@ -12046,7 +12115,7 @@ var foreignKey4 = (columnsOrSpec, target, referencedColumns) => isObject(columns
     initiallyDeferred: spec.initiallyDeferred
   });
 })() : foreignKey(columnsOrSpec, target, referencedColumns);
-var check2 = (nameOrSpec, predicate) => isObject(nameOrSpec) ? (() => {
+var check3 = (nameOrSpec, predicate) => isObject(nameOrSpec) ? (() => {
   const spec = nameOrSpec;
   const specPredicate = spec.predicate;
   const placeholder = {
@@ -12077,6 +12146,9 @@ var check2 = (nameOrSpec, predicate) => isObject(nameOrSpec) ? (() => {
     predicate: predicateOrFactory
   });
 })();
+var selectSchema3 = selectSchema2;
+var insertSchema3 = insertSchema2;
+var updateSchema3 = updateSchema2;
 
 // src/postgres/schema.ts
 var schema5 = (schemaName) => ({
@@ -12088,11 +12160,11 @@ var schema5 = (schemaName) => ({
 var exports_renderer2 = {};
 __export(exports_renderer2, {
   postgres: () => postgres,
-  make: () => make8,
+  make: () => make7,
   TypeId: () => TypeId9
 });
-var make8 = (options3 = {}) => make5("postgres", (plan) => renderPostgresPlan(plan, options3));
-var postgres = make8();
+var make7 = (options3 = {}) => make4("postgres", (plan) => renderPostgresPlan(plan, options3));
+var postgres = make7();
 export {
   sequence,
   schema5 as schema,