effect-qb 0.17.0 → 4.0.0-beta.66

package/dist/sqlite.js

@@ -312,7 +312,7 @@ var references = (target) => foreignKey(target);
 
 // src/internal/runtime/value.ts
 import * as Schema3 from "effect/Schema";
-var brandString = (pattern2, brand5) => Schema3.String.pipe(Schema3.pattern(pattern2), Schema3.brand(brand5));
+var brandString = (pattern, brand5) => Schema3.String.pipe(Schema3.check(Schema3.isPattern(pattern)), Schema3.brand(brand5));
 var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
 var isValidLocalDateString = (value) => {
   const match = localDatePattern.exec(value);
@@ -365,11 +365,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();
@@ -409,13 +409,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/sqlite/datatypes/index.ts
 var exports_datatypes = {};
@@ -590,7 +599,7 @@ var custom = (schema2, dbType) => makeColumnDefinition(schema2, {
   ddlType: undefined,
   identity: undefined
 });
-var uuid = () => primitive(Schema4.UUID, sqliteDatatypes.uuid());
+var uuid = () => primitive(Schema4.String.check(Schema4.isUUID()), sqliteDatatypes.uuid());
 var text = () => primitive(Schema4.String, sqliteDatatypes.text());
 var int = () => primitive(Schema4.Int, sqliteDatatypes.int());
 var number = (options) => makeColumnDefinition(DecimalStringSchema, {
@@ -1087,12 +1096,7 @@ var validateOptions = (tableName, fields2, options) => {
 };
 
 // src/internal/schema-derivation.ts
-import * as VariantSchema from "@effect/experimental/VariantSchema";
 import * as Schema5 from "effect/Schema";
-var TableSchema = VariantSchema.make({
-  variants: ["select", "insert", "update"],
-  defaultVariant: "select"
-});
 var maybeBrandSchema = (column, tableName, columnName) => column.metadata.brand === true ? Schema5.brand(`${tableName}.${columnName}`)(column.schema) : column.schema;
 var selectSchema = (column, tableName, columnName) => column.metadata.nullable ? Schema5.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
 var insertSchema = (column, tableName, columnName) => {
@@ -1109,42 +1113,37 @@ var updateSchema = (column, tableName, columnName, isPrimaryKey) => {
   const base = column.metadata.nullable ? Schema5.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
   return Schema5.optional(base);
 };
-var deriveSchemas = (tableName, fields2, 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, fields2, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
-  const variants = {};
+  const structFields = {};
   for (const [key, column] of Object.entries(fields2)) {
-    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 schema3 = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+    if (schema3 !== undefined) {
+      structFields[key] = schema3;
     }
-    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 Schema5.Struct(structFields);
 };
+var deriveSelectSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("select", tableName, fields2, primaryKeyColumns);
+var deriveInsertSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("insert", tableName, fields2, primaryKeyColumns);
+var deriveUpdateSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("update", tableName, fields2, 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() {
@@ -1167,14 +1166,86 @@ var buildArtifacts = (name, fields2, declaredOptions, schemaName) => {
   validateOptions(name, fields2, declaredOptions);
   const primaryKey3 = resolvePrimaryKeyColumns(fields2, declaredOptions);
   const columns = Object.fromEntries(Object.entries(fields2).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)]));
-  const schemas = deriveSchemas(name, fields2, primaryKey3);
   return {
     columns,
-    schemas,
     normalizedOptions,
     primaryKey: primaryKey3
   };
 };
+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 schema3 = deriveTableSchema(table, variant);
+  cache[variant] = schema3;
+  return schema3;
+};
+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, fields2, declaredOptions, baseName = name, kind = "schema", schemaName, schemaMode = "default") => {
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
   const artifacts = buildArtifacts(name, fields2, declaredOptions, resolvedSchemaName);
@@ -1182,7 +1253,7 @@ var makeTable = (name, fields2, 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,
@@ -1255,7 +1326,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
   };
@@ -1278,7 +1348,7 @@ var makeOption = (option) => {
   return builder;
 };
 var option = (spec) => makeOption(spec);
-function make2(name, fields2, schemaName) {
+function make(name, fields2, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields2, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
@@ -1295,7 +1365,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,
@@ -1336,7 +1406,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]);
@@ -1406,7 +1476,7 @@ var foreignKey2 = (columns, target, referencedColumns) => makeOption({
     knownColumns: Object.keys(target()[TypeId4].fields)
   })
 });
-var check = (name, predicate) => makeOption({
+var check2 = (name, predicate) => makeOption({
   kind: "check",
   name,
   predicate
@@ -5918,20 +5988,21 @@ 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 Schema9 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/driver-value-mapping.ts
@@ -6108,7 +6179,7 @@ var renderJsonSelectSql = (sql, context) => {
 import * as Schema8 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
-var FiniteNumberSchema = Schema8.Number.pipe(Schema8.finite());
+var FiniteNumberSchema = Schema8.Number.check(Schema8.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
@@ -6136,14 +6207,11 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema8.Uint8ArrayFromSelf;
+      return Schema8.Uint8Array;
     case "array":
       return Schema8.Array(Schema8.Unknown);
     case "record":
-      return Schema8.Record({
-        key: Schema8.String,
-        value: Schema8.Unknown
-      });
+      return Schema8.Record(Schema8.String, Schema8.Unknown);
     case "null":
       return Schema8.Null;
     case "unknown":
@@ -6181,22 +6249,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 index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
+      const index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "String");
       return index4?.type;
     }
     case "Union": {
@@ -6212,21 +6276,17 @@ var propertyAstOf = (ast, key2) => {
 };
 var numberAstOf = (ast, index4) => {
   switch (ast._tag) {
-    case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index4);
-    case "Refinement":
-      return numberAstOf(ast.from, index4);
     case "Suspend":
-      return numberAstOf(ast.f(), index4);
-    case "TupleType": {
+      return numberAstOf(ast.thunk(), index4);
+    case "Arrays": {
       const element = ast.elements[index4];
       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) => {
@@ -6241,7 +6301,7 @@ var numberAstOf = (ast, index4) => {
 };
 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);
@@ -6271,28 +6331,28 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema8.Union(...resolved);
+  return Schema8.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;
   }
@@ -6301,14 +6361,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 Schema8.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema8.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values2, context) => Schema8.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -6505,24 +6565,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[TypeId].dbType,
-  raw,
-  normalized,
-  stage,
-  cause
-});
+var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
+  const schemaError = Schema9.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[TypeId].dbType,
+    raw,
+    normalized,
+    stage,
+    cause,
+    ...schemaError === undefined ? {} : { schemaError }
+  };
+};
 var hasOptionalSourceDependency = (expression, scope) => {
   const state = expression[TypeId];
   return Object.keys(state.dependencies).some((sourceName) => !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional");
@@ -6565,8 +6632,8 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
         driverValueMapping: expression[TypeId].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);
@@ -6592,11 +6659,15 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (Schema9.is(schema4)(normalized)) {
     return normalized;
   }
-  try {
-    return Schema9.decodeUnknownSync(schema4)(normalized);
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
+  const decoded = Schema9.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);
@@ -6619,15 +6690,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);
@@ -6650,7 +6717,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)))));
@@ -6676,7 +6743,7 @@ var validateProjectionPathsMatchSelection = (plan, projections) => {
     }
   }
 };
-function make5(dialect, render) {
+function make4(dialect, render) {
   if (typeof render !== "function") {
     throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
   }
@@ -8184,8 +8251,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") {
@@ -8200,13 +8267,13 @@ var sqlClientDriver = () => driver2({
   execute: (query) => Effect2.flatMap(SqlClient3.SqlClient, (sql) => sql.unsafe(query.sql, [...query.params])),
   stream: (query) => Stream2.unwrap(Effect2.map(Effect2.flatMap(SqlClient3.SqlClient, (sql) => sql.unsafe(query.sql, [...query.params])), (rows) => Stream2.fromIterable(rows)))
 });
-function make6(options2 = {}) {
+function make5(options2 = {}) {
   if (options2.driver) {
-    return fromDriver(options2.renderer ?? make5("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
+    return fromDriver(options2.renderer ?? make4("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
   }
-  return fromDriver(options2.renderer ?? make5("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
+  return fromDriver(options2.renderer ?? make4("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
-var custom3 = (execute) => make4("sqlite", execute);
+var custom3 = (execute) => make3("sqlite", execute);
 // src/sqlite/query.ts
 var exports_query2 = {};
 __export(exports_query2, {
@@ -8302,14 +8369,17 @@ var from2 = exportedFrom;
 // src/sqlite/table.ts
 var exports_table2 = {};
 __export(exports_table2, {
+  updateSchema: () => updateSchema3,
   unique: () => unique4,
+  selectSchema: () => selectSchema3,
   schema: () => schema4,
   primaryKey: () => primaryKey4,
   options: () => options2,
-  make: () => make7,
+  make: () => make6,
+  insertSchema: () => insertSchema3,
   index: () => index4,
   foreignKey: () => foreignKey3,
-  check: () => check2,
+  check: () => check3,
   alias: () => alias2,
   TypeId: () => TypeId10,
   OptionsSymbol: () => OptionsSymbol2,
@@ -8318,7 +8388,7 @@ __export(exports_table2, {
 var TypeId10 = TypeId4;
 var OptionsSymbol2 = OptionsSymbol;
 var options2 = options;
-var make7 = (name, fields2, schemaName = undefined) => make2(name, fields2, schemaName);
+var make6 = (name, fields2, schemaName = undefined) => make(name, fields2, schemaName);
 var schema4 = (schemaName) => {
   const table = (name, fields2, ...declaredOptions) => schema3(schemaName).table(name, fields2, ...declaredOptions);
   return {
@@ -8335,16 +8405,19 @@ var primaryKey4 = primaryKey3;
 var unique4 = unique3;
 var index4 = index2;
 var foreignKey3 = (columns, target, referencedColumns) => foreignKey2(columns, target, referencedColumns);
-var check2 = check;
+var check3 = check2;
+var selectSchema3 = selectSchema2;
+var insertSchema3 = insertSchema2;
+var updateSchema3 = updateSchema2;
 // src/sqlite/renderer.ts
 var exports_renderer2 = {};
 __export(exports_renderer2, {
   sqlite: () => sqlite,
-  make: () => make8,
+  make: () => make7,
   TypeId: () => TypeId8
 });
-var make8 = (options3 = {}) => make5("sqlite", (plan) => renderSqlitePlan(plan, options3));
-var sqlite = make8();
+var make7 = (options3 = {}) => make4("sqlite", (plan) => renderSqlitePlan(plan, options3));
+var sqlite = make7();
 export {
   exports_table2 as Table,
   exports_scalar as Scalar,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-qb",
-  "version": "0.17.0",
+  "version": "4.0.0-beta.66",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -57,9 +57,7 @@
     "@typescript/native-preview": "beta"
   },
   "dependencies": {
-    "@effect/experimental": "^0.57.0",
-    "@effect/sql": "^0.48.0",
-    "effect": "^3.19.3",
+    "effect": "4.0.0-beta.66",
     "pgsql-ast-parser": "^12.0.2"
   }
 }