effect-qb 0.14.0 → 0.15.0

package/dist/postgres/metadata.js

@@ -27,9 +27,9 @@ __export(exports_metadata, {
 // src/internal/table.ts
 import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
 
-// src/internal/plan.ts
-var exports_plan = {};
-__export(exports_plan, {
+// src/internal/row-set.ts
+var exports_row_set = {};
+__export(exports_row_set, {
   TypeId: () => TypeId
 });
 var TypeId = Symbol.for("effect-qb/Plan");
@@ -38,9 +38,9 @@ var TypeId = Symbol.for("effect-qb/Plan");
 import { pipeArguments } from "effect/Pipeable";
 import * as Schema from "effect/Schema";
 
-// src/internal/expression.ts
-var exports_expression = {};
-__export(exports_expression, {
+// src/internal/scalar.ts
+var exports_scalar = {};
+__export(exports_scalar, {
   TypeId: () => TypeId2
 });
 var TypeId2 = Symbol.for("effect-qb/Expression");
@@ -56,8 +56,18 @@ var ColumnProto = {
     return pipeArguments(this, arguments);
   }
 };
+var attachPipe = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments(value, arguments);
+    }
+  });
+  return value;
+};
 var makeColumnDefinition = (schema, metadata) => {
-  const column = Object.create(ColumnProto);
+  const column = attachPipe(Object.create(ColumnProto));
   column.schema = schema;
   column.metadata = metadata;
   column[TypeId2] = {
@@ -66,9 +76,7 @@ var makeColumnDefinition = (schema, metadata) => {
     runtimeSchema: schema,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
-    aggregation: "scalar",
-    source: undefined,
-    sourceNullability: "propagate",
+    kind: "scalar",
     dependencies: {}
   };
   column[ColumnTypeId] = {
@@ -86,16 +94,14 @@ var makeColumnDefinition = (schema, metadata) => {
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
     identity: metadata.identity,
-    enum: metadata.enum,
-    source: undefined,
-    dependencies: {}
+    enum: metadata.enum
   };
   return column;
 };
 var remapColumnDefinition = (column, options = {}) => {
   const schema = options.schema ?? column.schema;
   const metadata = options.metadata ?? column.metadata;
-  const next = Object.create(ColumnProto);
+  const next = attachPipe(Object.create(ColumnProto));
   next.schema = schema;
   next.metadata = metadata;
   next[TypeId2] = {
@@ -135,7 +141,7 @@ var remapColumnDefinition = (column, options = {}) => {
 var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
   const brandName = `${tableName}.${columnName}`;
   const schema = column.metadata.brand === true ? Schema.brand(brandName)(column.schema) : column.schema;
-  const bound = Object.create(ColumnProto);
+  const bound = attachPipe(Object.create(ColumnProto));
   bound.schema = schema;
   bound.metadata = column.metadata;
   bound[TypeId2] = {
@@ -144,13 +150,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
     runtimeSchema: schema,
     nullability: column.metadata.nullable ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
-    aggregation: "scalar",
-    source: {
-      tableName,
-      columnName,
-      baseTableName
-    },
-    sourceNullability: "propagate",
+    kind: "scalar",
     dependencies: {
       [tableName]: true
     }
@@ -225,7 +225,9 @@ var collectInlineOptions = (fields) => {
           kind: "column",
           column: columnName,
           order: column.metadata.index.order,
-          nulls: column.metadata.index.nulls
+          nulls: column.metadata.index.nulls,
+          operatorClass: column.metadata.index.operatorClass,
+          collation: column.metadata.index.collation
         }],
         name: column.metadata.index.name,
         method: column.metadata.index.method,
@@ -379,6 +381,16 @@ var TableProto = {
     return pipeArguments2(this, arguments);
   }
 };
+var attachPipe2 = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments2(value, arguments);
+    }
+  });
+  return value;
+};
 var buildArtifacts = (name, fields, declaredOptions, schemaName) => {
   const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions];
   validateFieldDialects(name, fields);
@@ -397,7 +409,7 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
   const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName);
   const dialect = resolveFieldDialect(fields);
-  const table = Object.create(TableProto);
+  const table = attachPipe2(Object.create(TableProto));
   table.name = name;
   table.columns = artifacts.columns;
   table.schemas = artifacts.schemas;
@@ -448,7 +460,7 @@ var validateClassOptions = (declaredOptions) => {
 var resolveFieldDialect = (fields) => {
   const dialects = [...new Set(Object.values(fields).map((field) => field.metadata.dbType.dialect))];
   if (dialects.length === 0) {
-    return "postgres";
+    throw new Error("Cannot infer table dialect from an empty field set");
   }
   if (dialects.length > 1) {
     throw new Error(`Mixed table dialects are not supported: ${dialects.join(", ")}`);
@@ -507,7 +519,7 @@ var schema = (schemaName) => ({
 var alias = (table, aliasName) => {
   const state = table[TypeId4];
   const columns = Object.fromEntries(Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column, state.baseName, state.schemaName)]));
-  const aliased = Object.create(TableProto);
+  const aliased = attachPipe2(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
   aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey);
@@ -627,31 +639,6 @@ var check = (name, predicate) => makeOption({
   predicate
 });
 
-// src/internal/postgres-dialect.ts
-var quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
-var renderLiteral = (value, state) => {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  state.params.push(value);
-  return `$${state.params.length}`;
-};
-var postgresDialect = {
-  name: "postgres",
-  quoteIdentifier,
-  renderLiteral,
-  renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
-    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
-  },
-  renderConcat(values) {
-    return `(${values.join(" || ")})`;
-  }
-};
-
 // src/internal/schema-expression.ts
 import { parse, toSql } from "pgsql-ast-parser";
 import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
@@ -661,19 +648,48 @@ var SchemaExpressionProto = {
     return pipeArguments3(this, arguments);
   }
 };
+var attachPipe3 = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments3(value, arguments);
+    }
+  });
+  return value;
+};
 var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId5 in value);
 var fromAst = (ast) => {
-  const expression = Object.create(SchemaExpressionProto);
+  const expression = attachPipe3(Object.create(SchemaExpressionProto));
   expression[TypeId5] = {
-    dialect: "postgres",
     ast
   };
   return expression;
 };
+var fromSql = (sql) => {
+  const expression = attachPipe3(Object.create(SchemaExpressionProto));
+  expression[TypeId5] = {
+    sql: sql.trim()
+  };
+  return expression;
+};
 var parseExpression = (sql) => fromAst(parse(sql, "expr"));
-var toAst = (expression) => expression[TypeId5].ast;
-var render = (expression) => toSql.expr(expression[TypeId5].ast);
-var normalize = (expression) => parseExpression(render(expression));
+var toAst = (expression) => {
+  const ast = expression[TypeId5].ast;
+  if (ast !== undefined) {
+    return ast;
+  }
+  return parse(render(expression), "expr");
+};
+var render = (expression) => expression[TypeId5].sql ?? toSql.expr(toAst(expression));
+var normalize = (expression) => (() => {
+  const sql = render(expression);
+  try {
+    return parseExpression(sql);
+  } catch {
+    return fromSql(sql);
+  }
+})();
 
 // src/internal/query.ts
 import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
@@ -681,7 +697,7 @@ import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
 // src/internal/query-ast.ts
 var TypeId6 = Symbol.for("effect-qb/QueryAst");
 
-// src/internal/predicate-runtime.ts
+// src/internal/predicate/runtime.ts
 var trueFormula = () => ({ kind: "true" });
 var falseFormula = () => ({ kind: "false" });
 var atomFormula = (atom) => ({ kind: "atom", atom });
@@ -1184,7 +1200,7 @@ var formulaOfExpression = (value) => {
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
-      return left === undefined ? trueFormula() : allFormula(rest.map((value2) => formulaOfNeq(left, value2)));
+      return left === undefined ? trueFormula() : combineFacts(nonNullFactsOfExpression(left), allFormula(rest.map((value2) => formulaOfNeq(left, value2))));
     }
     case "between":
       return combineFacts(ast.values.reduce((current, entry) => combineFacts(current, nonNullFactsOfExpression(entry)), undefined), unknownTag("variadic:between"));
@@ -1226,35 +1242,45 @@ var PlanProto = {
   }
 };
 var QueryTypeId = Symbol.for("effect-qb/Query/internal");
-var normalizeSources = (source) => source === undefined ? [] : Array.isArray(source) ? source : [source];
-var mergeSources = (left, right) => {
-  const values = [...normalizeSources(left), ...normalizeSources(right)];
-  if (values.length === 0) {
-    return;
-  }
-  if (values.length === 1) {
-    return values[0];
-  }
-  return values;
-};
-var mergeDependencies = (left, right = {}) => ({
-  ...left,
-  ...right
+var mergeDependencies = (left, right = undefined) => ({
+  ...left ?? {},
+  ...right ?? {}
 });
 var mergeAggregationRuntime = (left, right = "scalar") => left === "window" || right === "window" ? "window" : left === "aggregate" || right === "aggregate" ? "aggregate" : "scalar";
-var mergeAggregationManyRuntime = (values) => values.reduce((current, value) => mergeAggregationRuntime(current, value[TypeId2].aggregation), "scalar");
+var mergeAggregationManyRuntime = (values) => values.reduce((current, value) => mergeAggregationRuntime(current, value[TypeId2].kind), "scalar");
 var mergeNullabilityRuntime = (left, right = "never") => left === "always" || right === "always" ? "always" : left === "maybe" || right === "maybe" ? "maybe" : "never";
 var mergeNullabilityManyRuntime = (values) => values.reduce((current, value) => mergeNullabilityRuntime(current, value[TypeId2].nullability), "never");
-var mergeManySources = (values) => values.reduce((current, value) => mergeSources(current, value[TypeId2].source), undefined);
 var mergeManyDependencies = (values) => values.reduce((current, value) => mergeDependencies(current, value[TypeId2].dependencies), {});
 var makeExpression = (state, ast) => {
   const expression = Object.create(ExpressionProto);
-  expression[TypeId2] = state;
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments4(expression, arguments);
+    }
+  });
+  expression[TypeId2] = {
+    runtime: state.runtime,
+    dbType: state.dbType,
+    runtimeSchema: state.runtimeSchema,
+    nullability: state.nullability,
+    dialect: state.dialect,
+    kind: state.kind ?? "scalar",
+    dependencies: state.dependencies ?? {}
+  };
   expression[TypeId3] = ast;
   return expression;
 };
 var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState) => {
   const plan = Object.create(PlanProto);
+  Object.defineProperty(plan, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments4(plan, arguments);
+    }
+  });
   plan[TypeId] = state;
   plan[TypeId6] = ast;
   plan[QueryTypeId] = {
@@ -1475,13 +1501,13 @@ var dedupeGroupedExpressions = (values) => {
 var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
 var selectionHasAggregate = (selection) => {
   if (isExpression2(selection)) {
-    return selection[TypeId2].aggregation === "aggregate";
+    return selection[TypeId2].kind === "aggregate";
   }
   return Object.values(selection).some((value) => selectionHasAggregate(value));
 };
 var isGroupedSelectionValid = (selection, groupedExpressions) => {
   if (isExpression2(selection)) {
-    const aggregation = selection[TypeId2].aggregation;
+    const aggregation = selection[TypeId2].kind;
     if (aggregation === "aggregate") {
       return true;
     }
@@ -1504,7 +1530,7 @@ var validateAggregationSelection = (selection, grouped) => {
   }
 };
 
-// src/internal/sql-expression-renderer.ts
+// src/postgres/internal/sql-expression-renderer.ts
 var renderDbType = (dialect, dbType) => {
   if (dialect.name === "mysql" && dbType.dialect === "mysql" && dbType.kind === "uuid") {
     return "char(36)";
@@ -2392,6 +2418,8 @@ var renderExpression = (expression, state, dialect) => {
       return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
     case "cast":
       return `cast(${renderExpression(ast.value, state, dialect)} as ${renderCastType(dialect, ast.target)})`;
+    case "collate":
+      return `(${renderExpression(ast.value, state, dialect)} collate ${ast.collation.map((segment) => dialect.quoteIdentifier(segment)).join(".")})`;
     case "function":
       return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect);
     case "eq":
@@ -2522,8 +2550,35 @@ var renderExpression = (expression, state, dialect) => {
   throw new Error("Unsupported expression for SQL rendering");
 };
 
-// src/internal/schema-ddl.ts
+// src/postgres/internal/schema-ddl.ts
 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) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  state.params.push(value);
+  return `$${state.params.length}`;
+};
+var postgresDialect = {
+  name: "postgres",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
+    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`;
+  }
+};
+
+// src/postgres/internal/schema-ddl.ts
 var escapeString = (value) => `'${value.replaceAll("'", "''")}'`;
 var inlineLiteralDialect = {
   ...postgresDialect,
@@ -2548,12 +2603,51 @@ var renderDdlExpressionSql = (expression) => isSchemaExpression(expression) ? re
   ctes: [],
   cteNames: new Set
 }, inlineLiteralDialect);
+var stripRedundantOuterParens = (value) => {
+  let current = value.trim();
+  while (current.startsWith("(") && current.endsWith(")")) {
+    let depth = 0;
+    let wrapsWholeExpression = true;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let index3 = 0;index3 < current.length; index3++) {
+      const char = current[index3];
+      const previous = index3 > 0 ? current[index3 - 1] : undefined;
+      if (char === "'" && !inDoubleQuote && previous !== "\\") {
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (char === '"' && !inSingleQuote && previous !== "\\") {
+        inDoubleQuote = !inDoubleQuote;
+        continue;
+      }
+      if (inSingleQuote || inDoubleQuote) {
+        continue;
+      }
+      if (char === "(") {
+        depth += 1;
+      } else if (char === ")") {
+        depth -= 1;
+        if (depth === 0 && index3 < current.length - 1) {
+          wrapsWholeExpression = false;
+          break;
+        }
+      }
+    }
+    if (!wrapsWholeExpression) {
+      break;
+    }
+    current = current.slice(1, -1).trim();
+  }
+  return current;
+};
+var canonicalizeDdlExpressionSql = (value) => stripRedundantOuterParens(value.trim().replace(/\s+/g, " ").replace(/"[^"]+"\./g, "").replace(/"([A-Za-z_][A-Za-z0-9_]*)"/g, "$1").replace(/\bCOLLATE\b/g, "collate").replace(/cast\(((?:'(?:[^']|'')*'|"[^"]+"|[a-zA-Z_][a-zA-Z0-9_]*|\([^()]+\))) as ([^)]+)\)/gi, (_, expression, target) => `${expression}::${target.trim()}`));
 var normalizeDdlExpressionSql = (expression) => {
   const rendered = renderDdlExpressionSql(expression);
   try {
-    return toSql2.expr(parse2(rendered, "expr"));
+    return canonicalizeDdlExpressionSql(toSql2.expr(parse2(rendered, "expr")));
   } catch {
-    return rendered.trim();
+    return canonicalizeDdlExpressionSql(rendered);
   }
 };
 
@@ -2630,7 +2724,7 @@ function sequence(name, schemaName) {
 }
 var isSequenceDefinition = (value) => typeof value === "object" && value !== null && (SequenceTypeId in value);
 
-// src/internal/postgres-schema-model.ts
+// src/postgres/internal/schema-model.ts
 var isTableDefinition = (value) => value !== null && (typeof value === "object" || typeof value === "function") && (TypeId4 in value);
 var isEnumDefinition = (value) => typeof value === "object" && value !== null && (EnumTypeId in value);
 var toTableModel = (table) => {