@happyvertical/sql 0.102.4 → 0.102.6

package/dist/index.d.ts

@@ -49,62 +49,20 @@ export type GetDatabaseOptions = (PostgresOptions & {
  * @throws Error if the database type is invalid
  */
 export declare function getDatabase(options?: GetDatabaseOptions | DatabaseInterface): Promise<DatabaseInterface>;
-/**
- * Synchronizes a SQL schema definition with a database
- * Creates tables if they don't exist and adds missing columns to existing tables
- *
- * @param options - Object containing database and schema
- * @param options.db - Database interface to use
- * @param options.schema - SQL schema definition
- * @throws Error if db or schema are missing or if the database doesn't support syncSchema
- */
-export declare function syncSchema(options: {
-    db: DatabaseInterface;
-    schema: string;
-}): Promise<void>;
-/**
- * Checks if a table exists in the database
- *
- * @param db - Database interface to use
- * @param tableName - Name of the table to check
- * @returns Promise resolving to boolean indicating if the table exists
- */
-export declare function tableExists(db: DatabaseInterface, tableName: string): Promise<boolean>;
-/**
- * Escapes and formats a value for use in SQL queries
- *
- * @param value - Value to escape
- * @returns String representation of the value safe for SQL use
- */
-export declare function escapeSqlValue(value: any): string;
-/**
- * Validates a column name for use in SQL queries
- *
- * @param column - Column name to validate
- * @returns The validated column name
- * @throws Error if the column name contains invalid characters
- */
-export declare function validateColumnName(column: string): string;
-import { buildWhere, formatDbError, raw } from "./shared/utils.js";
-export { type AggregateBuildResult, type AggregateFunction, type AggregateSelectExpr, type AggregateSpec, type AggregateTimeBucketUnit, bucketExpr, buildAggregate, } from './aggregate.js';
-export type { RawSqlKey, SqlAdapterType } from "./shared/utils.js";
-export { buildWhere, formatDbError, raw };
-import { convertUniqueIndexesToInlineConstraints } from "./shared/duckdb-schema-utils.js";
+import { raw, syncSchema, tableExists } from './query.js';
 export { checkExpectedTables, checkRelationship, checkUniqueColumn, type DoctorCheck, type DoctorContext, type DoctorIssue, type DoctorLevel, type DoctorResult, type RelationshipSpec, type RunDoctorOptions, runDoctor, type UniqueColumnSpec, } from "./doctor.js";
 export { clearConnectionCache } from './json.js';
 export type { PGliteLike, PGliteOptions } from "./pglite.js";
 export { clearPostgresConnectionCache } from './postgres.js';
 export { assertCanExportDatabase, assertCanImportDatabase, type CreateDropOptions, createPostgresDatabase, type DumpOptions, databaseNameFromUrl, dropPostgresDatabase, dumpPostgresDatabase, isLocalDatabaseUrl, type PostgresImportLocalityOptions, type PostgresLocalityOptions, postgresEnvFromUrl, type RestoreOptions, redactDatabaseUrl, restorePostgresDatabase, } from "./postgres-cli.js";
-export type { SchemaInitializationResult } from "./schema-manager.js";
-export { DatabaseSchemaManager } from "./schema-manager.js";
+export { type AggregateBuildResult, type AggregateFunction, type AggregateSelectExpr, type AggregateSpec, type AggregateTimeBucketUnit, bucketExpr, buildAggregate, buildWhere, convertUniqueIndexesToInlineConstraints, DatabaseSchemaManager, escapeSqlValue, formatDbError, type RawSqlKey, raw, type SchemaInitializationResult, type SqlAdapterType, syncSchema, tableExists, validateColumnName, } from './query.js';
 export * from "./shared/types.js";
 export type { SecureSqliteFileOptions, SqliteOptions } from './sqlite.js';
-export { convertUniqueIndexesToInlineConstraints };
 declare const _default: {
     getDatabase: typeof getDatabase;
     syncSchema: typeof syncSchema;
     tableExists: typeof tableExists;
-    buildWhere: (where: import("./index.js").WhereClause, startIndex?: number, adapterType?: import("./index.js").SqlAdapterType) => {
+    buildWhere: (where: import("./query.js").WhereClause, startIndex?: number, adapterType?: import("./query.js").SqlAdapterType) => {
         sql: string;
         values: any[];
     };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAY,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,WAAW,EACZ,MAAM,mBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAU,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC1B,CAAC,eAAe,GAAG;IAAE,IAAI,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC,GACzC,CAAC,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAC,GACrC,CAAC,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAC,GACrC,CAAC,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAC,GACrC,WAAW,CAAC;AAmBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,WAAW,CAC/B,OAAO,GAAE,kBAAkB,GAAG,iBAAsB,GACnD,OAAO,CAAC,iBAAiB,CAAC,CAqD5B;AAcD,OAAO,EAAc,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGtE,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,SAAS,EACT,KAAK,gBAAgB,GACtB,MAAM,aAAU,CAAC;AAElB,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAIjD,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAU,CAAC;AAC1D,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,sBAAsB,EACtB,KAAK,WAAW,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,6BAA6B,EAClC,KAAK,uBAAuB,EAC5B,kBAAkB,EAClB,KAAK,cAAc,EACnB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,mBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,UAAU,EACV,cAAc,EACd,UAAU,EACV,uCAAuC,EACvC,qBAAqB,EACrB,cAAc,EACd,aAAa,EACb,KAAK,SAAS,EACd,GAAG,EACH,KAAK,0BAA0B,EAC/B,KAAK,cAAc,EACnB,UAAU,EACV,WAAW,EACX,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,cAAc,mBAAgB,CAAC;AAC/B,YAAY,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;AAE1E,wBAME;AAEF,gBAAgB;AAChB,eAAO,MAAM,2BAA2B,OAAO,CAAC"}

package/dist/index.js

@@ -1,6 +1,8 @@
-import { C as parseConditionKey, D as wrapDatabaseError, E as unwrapRawKey, S as formatDbError, T as resolveInsertColumns, _ as validateColumnNames, a as createVectorCapabilities, b as DatabaseSchemaManager, c as createTransactionLock, d as validateDatabaseCacheOptions, f as escapeQuotedIdentifier, i as createTransactionErrorTracker, l as ConnectionCache, n as createGetTableSchema, o as normalizePostgresRawQuery, p as escapeStringLiteral, r as createPostgresDialect, t as createAlterTable, u as enableCachedValidation, w as raw, x as buildWhere } from "./chunks/postgres-dialect-Bfswr4Vs.js";
-import { n as throwWithDuckDBCleanup, r as convertUniqueIndexesToInlineConstraints, t as createDuckDBResourceCloser } from "./chunks/duckdb-resources-Cci6Lo6H.js";
+import { a as raw, c as wrapDatabaseError, n as buildWhere, o as resolveInsertColumns, r as formatDbError, t as DatabaseSchemaManager } from "./chunks/schema-manager-cxsySSDA.js";
+import { a as NestedTransactionError, c as bucketExpr, i as validateColumnName, l as buildAggregate, n as syncSchema, o as resolveSchemas, r as tableExists, s as convertUniqueIndexesToInlineConstraints, t as escapeSqlValue } from "./chunks/query-RzXJ4B9s.js";
 import { a as dropPostgresDatabase, c as postgresEnvFromUrl, i as databaseNameFromUrl, l as redactDatabaseUrl, n as assertCanImportDatabase, o as dumpPostgresDatabase, r as createPostgresDatabase, s as isLocalDatabaseUrl, t as assertCanExportDatabase, u as restorePostgresDatabase } from "./chunks/postgres-cli-DzZcXSIG.js";
+import { _ as validateColumnNames, a as createVectorCapabilities, c as createTransactionLock, d as validateDatabaseCacheOptions, f as escapeQuotedIdentifier, i as createTransactionErrorTracker, l as ConnectionCache, n as createGetTableSchema, o as normalizePostgresRawQuery, p as escapeStringLiteral, r as createPostgresDialect, t as createAlterTable, u as enableCachedValidation } from "./chunks/postgres-dialect-CGv6DxSP.js";
+import { n as throwWithDuckDBCleanup, t as createDuckDBResourceCloser } from "./chunks/duckdb-resources-DBlvosDo.js";
 import { t as redactDatabaseUrl$1 } from "./chunks/redact-database-url-CfMDvSdy.js";
 import { DatabaseError, loadEnvConfig } from "@happyvertical/utils";
 import { mkdir, readdir, stat } from "node:fs/promises";
@@ -20,149 +22,6 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region src/aggregate.ts
-var VALID_DIRECTIONS = /* @__PURE__ */ new Set(["ASC", "DESC"]);
-var VALID_BUCKET_UNITS = /* @__PURE__ */ new Set([
-	"minute",
-	"hour",
-	"day",
-	"week",
-	"month",
-	"quarter",
-	"year"
-]);
-function validateSqlIdentifier(identifier) {
-	if (typeof identifier !== "string" || !/^[a-zA-Z0-9_.]+$/.test(identifier)) throw new Error(`Invalid SQL identifier: ${identifier}`);
-	return identifier;
-}
-function normalizeAdapter(adapterType) {
-	return adapterType ?? "sqlite";
-}
-function placeholder(index) {
-	return `$${index}`;
-}
-function bucketExpr(adapterType, unit, column) {
-	if (!VALID_BUCKET_UNITS.has(unit)) throw new Error(`Invalid aggregate bucket unit: ${unit}`);
-	const col = validateSqlIdentifier(column);
-	const adapter = normalizeAdapter(adapterType);
-	if (adapter === "postgres" || adapter === "duckdb" || adapter === "json") return `date_trunc('${unit}', ${col})`;
-	switch (unit) {
-		case "minute": return `strftime('%Y-%m-%d %H:%M:00', ${col})`;
-		case "hour": return `strftime('%Y-%m-%d %H:00:00', ${col})`;
-		case "day": return `strftime('%Y-%m-%d 00:00:00', ${col})`;
-		case "week": return `strftime('%Y-%m-%d 00:00:00', date(${col}, printf('-%d days', (CAST(strftime('%w', ${col}) AS INTEGER) + 6) % 7)))`;
-		case "month": return `strftime('%Y-%m-01 00:00:00', ${col})`;
-		case "quarter": return `strftime('%Y-%m-%d 00:00:00', date(strftime('%Y-', ${col}) || printf('%02d', ((CAST(strftime('%m', ${col}) AS INTEGER) - 1) / 3) * 3 + 1) || '-01'))`;
-		case "year": return `strftime('%Y-01-01 00:00:00', ${col})`;
-	}
-}
-function aggregateExpression(expr) {
-	const normalizedFn = String(expr.fn).toLowerCase();
-	const fn = validateSqlIdentifier(String(expr.fn)).toUpperCase();
-	if (normalizedFn === "count" && !expr.column) {
-		if (expr.distinct) throw new Error(`Aggregate ${expr.fn} with distinct requires a column`);
-		return "COUNT(*)";
-	}
-	if (!expr.column) throw new Error(`Aggregate ${expr.fn} requires a column`);
-	const col = validateSqlIdentifier(expr.column);
-	return `${fn}(${expr.distinct ? "DISTINCT " : ""}${col})`;
-}
-function selectExpression(expr, adapterType) {
-	if ("column" in expr && !("fn" in expr) && !("bucket" in expr)) return {
-		expression: validateSqlIdentifier(expr.column),
-		alias: validateSqlIdentifier(expr.as ?? expr.column),
-		groupingCandidate: true
-	};
-	if ("bucket" in expr) return {
-		expression: bucketExpr(adapterType, expr.bucket, expr.column),
-		alias: validateSqlIdentifier(expr.as),
-		groupingCandidate: true
-	};
-	return {
-		expression: aggregateExpression(expr),
-		alias: validateSqlIdentifier(expr.as),
-		groupingCandidate: false
-	};
-}
-function expandHavingKey(key, expressionByAlias) {
-	if (unwrapRawKey(key).isRaw) return key;
-	const parsed = parseConditionKey(key);
-	return raw(`${expressionByAlias.get(parsed.field) ?? validateSqlIdentifier(parsed.field)} ${parsed.operator}`);
-}
-function expandHaving(having, expressionByAlias) {
-	const expandCondition = (condition) => Object.fromEntries(Object.entries(condition).map(([key, value]) => [expandHavingKey(key, expressionByAlias), value]));
-	if (Array.isArray(having)) return having.map((andGroup) => andGroup.map((condition) => expandCondition(condition)));
-	return expandCondition(having);
-}
-function buildHaving(having, expressionByAlias, startIndex, adapterType) {
-	if (!having) return {
-		sql: "",
-		values: []
-	};
-	const built = buildWhere(expandHaving(having, expressionByAlias), startIndex, adapterType);
-	return {
-		sql: built.sql ? built.sql.replace(/^WHERE/, "HAVING") : "",
-		values: built.values
-	};
-}
-function buildOrderBy(orderBy) {
-	if (!orderBy) return "";
-	return `ORDER BY ${(Array.isArray(orderBy) ? orderBy : [orderBy]).map((item) => {
-		const [field, direction = "ASC"] = item.trim().split(/\s+/);
-		const normalizedDirection = direction.toUpperCase();
-		if (!VALID_DIRECTIONS.has(normalizedDirection)) throw new Error(`Invalid aggregate order direction: ${direction}`);
-		return `${validateSqlIdentifier(field)} ${normalizedDirection}`;
-	}).join(", ")}`;
-}
-function buildAggregate(spec, startIndex = 1, adapterType) {
-	const from = validateSqlIdentifier(spec.from);
-	if (spec.select.length === 0) throw new Error("AggregateSpec.select must contain at least one expression");
-	const expressionByAlias = /* @__PURE__ */ new Map();
-	const groupingAliases = [];
-	const selectSql = spec.select.map((expr) => {
-		const selected = selectExpression(expr, adapterType);
-		expressionByAlias.set(selected.alias, selected.expression);
-		if (selected.groupingCandidate) groupingAliases.push(selected.alias);
-		return `${selected.expression} AS ${selected.alias}`;
-	});
-	const where = spec.where ? buildWhere(spec.where, startIndex, adapterType) : {
-		sql: "",
-		values: []
-	};
-	let nextParamIndex = startIndex + where.values.length;
-	const groupByItems = spec.groupBy ?? groupingAliases;
-	const groupBySql = groupByItems.length > 0 ? `GROUP BY ${groupByItems.map((item) => expressionByAlias.has(item) ? expressionByAlias.get(item) : validateSqlIdentifier(item)).join(", ")}` : "";
-	const having = buildHaving(spec.having, expressionByAlias, nextParamIndex, adapterType);
-	nextParamIndex += having.values.length;
-	const orderBySql = buildOrderBy(spec.orderBy);
-	const pagingValues = [];
-	const pagingSql = [];
-	if (spec.limit !== void 0) {
-		pagingSql.push(`LIMIT ${placeholder(nextParamIndex++)}`);
-		pagingValues.push(spec.limit);
-	} else if (spec.offset !== void 0 && normalizeAdapter(adapterType) === "sqlite") pagingSql.push("LIMIT -1");
-	if (spec.offset !== void 0) {
-		pagingSql.push(`OFFSET ${placeholder(nextParamIndex++)}`);
-		pagingValues.push(spec.offset);
-	}
-	return {
-		sql: [
-			`SELECT ${selectSql.join(", ")}`,
-			`FROM ${from}`,
-			where.sql,
-			groupBySql,
-			having.sql,
-			orderBySql,
-			pagingSql.join(" ")
-		].filter(Boolean).join(" "),
-		values: [
-			...where.values,
-			...having.values,
-			...pagingValues
-		]
-	};
-}
-//#endregion
 //#region src/doctor.ts
 /**
 * Database integrity-check framework.
@@ -298,48 +157,6 @@ function countValueFromRow(value) {
 	return "0";
 }
 //#endregion
-//#region src/shared/types.ts
-/**
-* Error thrown when `transaction()` is called on a transaction-scoped interface
-* belonging to an adapter whose engine has no savepoints.
-*
-* DuckDB — and therefore the JSON adapter built on it — does not implement
-* `SAVEPOINT`, so there is no way to re-enter the current transaction. Adapters
-* that can re-enter (PostgreSQL, SQLite) do so under a savepoint and never
-* throw this.
-*
-* The alternative would be to open a second, independent transaction, which is
-* what these adapters used to do; on a shared connection that silently
-* destroyed the enclosing transaction's uncommitted work.
-*
-* @example Ensuring a helper works on every adapter
-* ```typescript
-* // Take the transaction as a parameter rather than opening a nested one.
-* async function recordClick(db: DatabaseInterface, id: string) {
-*   await db.update('links', { id }, { clicks: 1 });
-* }
-* await db.transaction(async (tx) => recordClick(tx, id));
-* ```
-*/
-var NestedTransactionError = class extends DatabaseError {
-	constructor(message, context) {
-		super(message, context);
-		this.name = "NestedTransactionError";
-	}
-};
-/**
-* Resolves a SchemasOption to its concrete value.
-*
-* Adapters that need schemas (JSON, DuckDB) call this to unwrap the
-* lazy function. Adapters that don't (Postgres, SQLite) simply ignore
-* the `schemas` option without calling this.
-*/
-function resolveSchemas(schemas) {
-	if (!schemas) return void 0;
-	if (typeof schemas === "function") return schemas();
-	return schemas;
-}
-//#endregion
 //#region src/json.ts
 var json_exports = /* @__PURE__ */ __exportAll({
 	clearConnectionCache: () => clearConnectionCache,
@@ -2550,60 +2367,11 @@ async function getDatabase(options = {}) {
 	if (!options.type && (options.url?.startsWith("file:") || options.url === ":memory:")) options.type = "sqlite";
 	if (options.type === "postgres") return (await Promise.resolve().then(() => postgres_exports)).getDatabase(options);
 	if (options.type === "pglite") return (await import("./pglite.js")).getDatabase(options);
-	if (options.type === "sqlite") return (await import("./chunks/sqlite-0PMv1va2.js")).getDatabase(options);
-	if (options.type === "duckdb") return (await import("./chunks/duckdb-LMyfKZGi.js")).getDatabase(options);
+	if (options.type === "sqlite") return (await import("./chunks/sqlite-rILMdW7Z.js")).getDatabase(options);
+	if (options.type === "duckdb") return (await import("./chunks/duckdb-c4vdDzPL.js")).getDatabase(options);
 	if (options.type === "json") return (await Promise.resolve().then(() => json_exports)).getDatabase(options);
 	throw new Error("Invalid database type");
 }
-/**
-* Synchronizes a SQL schema definition with a database
-* Creates tables if they don't exist and adds missing columns to existing tables
-*
-* @param options - Object containing database and schema
-* @param options.db - Database interface to use
-* @param options.schema - SQL schema definition
-* @throws Error if db or schema are missing or if the database doesn't support syncSchema
-*/
-async function syncSchema(options) {
-	const { db, schema } = options;
-	if (!db || !schema) throw new Error("db and schema are required");
-	if (db.syncSchema) await db.syncSchema(schema);
-	else throw new Error("Database adapter does not support schema synchronization");
-}
-/**
-* Checks if a table exists in the database
-*
-* @param db - Database interface to use
-* @param tableName - Name of the table to check
-* @returns Promise resolving to boolean indicating if the table exists
-*/
-async function tableExists(db, tableName) {
-	return db.tableExists(tableName);
-}
-/**
-* Escapes and formats a value for use in SQL queries
-*
-* @param value - Value to escape
-* @returns String representation of the value safe for SQL use
-*/
-function escapeSqlValue(value) {
-	if (value === null) return "NULL";
-	if (value instanceof Date) return `'${value.toISOString()}'`;
-	if (typeof value === "number") return value.toString();
-	if (typeof value === "boolean") return value ? "1" : "0";
-	return `'${String(value).replace(/'/g, "''")}'`;
-}
-/**
-* Validates a column name for use in SQL queries
-*
-* @param column - Column name to validate
-* @returns The validated column name
-* @throws Error if the column name contains invalid characters
-*/
-function validateColumnName(column) {
-	if (typeof column !== "string" || !/^[a-zA-Z0-9_.]+$/.test(column)) throw new Error(`Invalid column name: ${column}`);
-	return column;
-}
 var src_default = {
 	getDatabase,
 	syncSchema,