@atscript/db-postgres 0.1.147 → 0.1.148

package/dist/index.cjs

@@ -3,6 +3,77 @@ let _atscript_db = require("@atscript/db");
 let _atscript_db_agg = require("@atscript/db/agg");
 let _atscript_db_sql_tools = require("@atscript/db-sql-tools");
 let _uniqu_core = require("@uniqu/core");
+//#region src/insert-ignore.ts
+/**
+* Whether two key values are the same value written differently: a number
+* and its decimal text (`5` / `"5.00"` of a NUMERIC column), a string and its
+* blank-padded form (`"ab"` / `"ab   "` of a CHAR(n) column), or in another
+* letter case (`uuid`, `citext`).
+*/
+function looselySame(a, b) {
+	const textA = typeof a === "number" || typeof a === "string" ? `${a}` : void 0;
+	const textB = typeof b === "number" || typeof b === "string" ? `${b}` : void 0;
+	if (textA === void 0 || textB === void 0) return false;
+	const na = Number(textA);
+	const nb = Number(textB);
+	if (textA.trim() !== "" && textB.trim() !== "" && Number.isFinite(na) && na === nb) return true;
+	return typeof a === "string" && typeof b === "string" && a.trimEnd().toLowerCase() === b.trimEnd().toLowerCase();
+}
+/** A key value the server may store in another form than it was sent (NUMERIC / decimal rounding). */
+function mayNormalize(value, col, formCols) {
+	if (typeof value === "string" && col !== void 0 && formCols?.has(col)) return true;
+	return typeof value === "number" && !Number.isInteger(value) || typeof value === "string" && /^-?\d+\.\d+$/.test(value);
+}
+/**
+* Maps the rows a batched `INSERT … ON CONFLICT DO NOTHING RETURNING <keys>`
+* returned back to the batch's input rows.
+*
+* PostgreSQL returns the inserted rows in VALUES order and omits skipped ones,
+* so `returned` is an in-order subsequence of `batch`. A row is inserted
+* exactly when the next returned row carries EVERY key set the row fully
+* defines (key sets with an absent / null input component are never compared:
+* a generated key's value is unknown to the input). Result: per input row, the
+* index of its returned row, or `-1` when it was skipped.
+*
+* `undefined` when the mapping is not provably exact — a row that defines no
+* complete key set (it may match a returned row only by a generated value), a
+* skipped-looking row whose key a server could have normalized (non-integer
+* numbers / decimals), a key equal to the returned one only when written
+* differently (`5` / `"5.00"`, blank-padded CHAR, a `uuid` / `citext` in another
+* letter case — the server lower-cases a returned uuid, so `"AAA"` / `"aaa"` could
+* swap the mapping), or returned rows left unaccounted for (counts or keys that
+* do not line up with an in-order subsequence). The caller must then redo the
+* chunk row by row. An empty `returned` (everything skipped) and a fully-returned
+* batch (everything inserted) are exact without any matching.
+*
+* @param keySets Physical column names of the primary key and every unique index.
+* @param formCols Key columns whose physical type is not text (uuid, inet, cidr,
+*   macaddr, …, `@db.pg.type` overrides): a string key there may come back
+*   normalized, so a skipped-looking row of such a key is ambiguous.
+*/
+function mapIgnoredBatch(batch, returned, keySets, formCols) {
+	if (returned.length === 0) return batch.map(() => -1);
+	if (returned.length === batch.length) return batch.map((_, i) => i);
+	const out = [];
+	let next = 0;
+	for (const row of batch) {
+		const tuples = keySets.map((cols) => (0, _atscript_db.uniqueKeyTuple)(row, cols));
+		if (tuples.every((t) => t === void 0)) return void 0;
+		const candidate = returned[next];
+		if (candidate !== void 0) {
+			const strict = keySets.map((cols, k) => tuples[k] === void 0 || tuples[k] === (0, _atscript_db.uniqueKeyTuple)(candidate, cols));
+			if (strict.every(Boolean)) {
+				out.push(next++);
+				continue;
+			}
+			if (keySets.every((cols, k) => tuples[k] === void 0 || strict[k] || cols.every((c) => looselySame(row[c], candidate[c])))) return void 0;
+		}
+		if (keySets.some((cols, k) => tuples[k] !== void 0 && cols.some((c) => mayNormalize(row[c], c, formCols)))) return;
+		out.push(-1);
+	}
+	return next === returned.length ? out : void 0;
+}
+//#endregion
 //#region src/sql-builder.ts
 /**
 * PostgreSQL-aware default value for a given design type.
@@ -80,6 +151,25 @@ const pgDialect = {
 	calendarBucket: pgCalendarBucket,
 	jsonExtract: pgJsonExtract,
 	castDouble: (expr) => `CAST(${expr} AS DOUBLE PRECISION)`,
+	anyValue: pgAnyValue,
+	booleanAggregates: {
+		min: "BOOL_AND",
+		max: "BOOL_OR"
+	},
+	/**
+	* SQLSTATE 22003 (`numeric_value_out_of_range`), a double overflow in
+	* aggregate arithmetic, is `INVALID_QUERY`; SQLSTATE 22023
+	* (`invalid_parameter_value`, `time zone "…" not recognized`), raised by a
+	* calendar bucket's `AT TIME ZONE '<tz>'`, is `BUCKET_TZ_UNAVAILABLE` — the
+	* zone passed the core's IANA validation, so the server's tz database is
+	* older than the runtime's.
+	*/
+	mapQueryError(error, arithmetic) {
+		const err = error;
+		if (err?.code === "22003") return arithmetic ? (0, _atscript_db_sql_tools.arithOverflowError)() : (0, _atscript_db_sql_tools.numericOutOfRangeError)();
+		const zone = err?.code === "22023" && typeof err.message === "string" ? /time zone "([^"]*)" not recognized/.exec(err.message)?.[1] : void 0;
+		return zone === void 0 ? void 0 : (0, _atscript_db.bucketTimeZoneUnavailable)(`PostgreSQL does not recognize time zone "${zone}" — update the server's time zone data`);
+	},
 	nullsSortLargest: true,
 	createViewPrefix: "CREATE OR REPLACE VIEW",
 	paramPlaceholder(index) {
@@ -257,6 +347,30 @@ function intTypeFromTags(tags) {
 	if (tags?.has("int64") || tags?.has("uint64")) return "BIGINT";
 	return "INTEGER";
 }
+/** Physical types `MIN` aggregates (base name, lower-cased): the streaming pick applies. */
+const MIN_ORDERED_TYPE = /^(smallint|int2|integer|int|int4|bigint|int8|real|float4|double precision|float8|numeric|decimal|money|text|varchar|character varying|char|character|bpchar|date|time|timetz|timestamp|timestamptz|interval|time (with|without) time zone|timestamp (with|without) time zone)\b/;
+/** Text key types: a value comes back in the form it was sent (modulo case for `citext`), so a returned key maps to its input row. */
+const TEXT_KEY_TYPE = /^(text|varchar|character varying|char|character|bpchar|citext)\b/;
+/** `true` when the physical column type `type` is a text type (see {@link TEXT_KEY_TYPE}). */
+function isTextKeyType(type) {
+	return TEXT_KEY_TYPE.test(type.trim().toLowerCase());
+}
+/**
+* The "any value of the group" pick of a `first` / `last` derived column
+* (constant within its group) over a PostgreSQL column: `MIN` (streaming — one
+* accumulator per group) for the ordered types and for every array column
+* (`MIN(anyarray)`; `ARRAY_AGG` over arrays builds a 2-D array and rejects NULL /
+* empty ones), `BOOL_AND` for a boolean, and `(ARRAY_AGG(x))[1]` only where the
+* physical type has no `MIN` (uuid, bytea, point, json / jsonb, citext,
+* `@db.pg.type` overrides, …) or is unknown.
+*/
+function pgAnyValue(expr, field) {
+	const type = field ? pgTypeFromField(field).trim().toLowerCase() : "";
+	if (type.endsWith("[]")) return `MIN(${expr})`;
+	if (/^bool(ean)?\b/.test(type)) return `BOOL_AND(${expr})`;
+	if (MIN_ORDERED_TYPE.test(type)) return `MIN(${expr})`;
+	return `(ARRAY_AGG(${expr}))[1]`;
+}
 /**
 * Maps an Atscript field descriptor to a PostgreSQL column type.
 *
@@ -312,11 +426,11 @@ function buildCreateTable(table, fields, foreignKeys, options) {
 			continue;
 		}
 		let def = `${qi(field.physicalName)} ${sqlType}`;
-		if (options?.incrementFields?.has(field.physicalName)) {
+		if (options?.incrementFields?.has(field.path)) {
 			const start = options.autoIncrementStart;
 			def += start !== void 0 ? ` GENERATED BY DEFAULT AS IDENTITY (START WITH ${start})` : " GENERATED BY DEFAULT AS IDENTITY";
 		}
-		if (!field.optional && !field.isPrimaryKey && !options?.incrementFields?.has(field.physicalName)) def += " NOT NULL";
+		if (!field.optional && !field.isPrimaryKey && !options?.incrementFields?.has(field.path)) def += " NOT NULL";
 		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
 		else if (field.defaultValue?.kind === "fn") {
 			if (field.defaultValue.fn === "uuid") def += " DEFAULT gen_random_uuid()";
@@ -386,6 +500,8 @@ function parseCount(value) {
 * ```
 */
 /** The suffix PostgreSQL gives an auto-named constraint of each `pg_constraint.contype`. */
+/** Savepoint guarding one `insertManyIgnore` chunk (see {@link PostgresAdapter.insertManyIgnore}). */
+const IGNORE_SAVEPOINT = "atscript_ignore_chunk";
 const PG_CONSTRAINT_LABELS = {
 	p: "pkey",
 	u: "key",
@@ -528,10 +644,14 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 	calendarBucketUnits() {
 		return _atscript_db.ALL_BUCKET_UNITS;
 	}
-	/** Every aggregate function, `countDistinct` included. */
+	/** Every aggregate function: `countDistinct`, `first` and `last` included. */
 	aggregateFns() {
 		return _atscript_db.ALL_AGGREGATE_FNS;
 	}
+	/** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+	supportsAggregateExpressions() {
+		return true;
+	}
 	/** Computed view columns and first-row joins. */
 	viewCapabilities() {
 		return _atscript_db.ALL_VIEW_CAPABILITIES;
@@ -601,16 +721,20 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 		try {
 			return await fn();
 		} catch (error) {
-			if (error && typeof error === "object" && "code" in error) {
-				const err = error;
-				if (err.code === "23505") throw new _atscript_db.DbError("CONFLICT", [{
-					path: this._extractFieldFromConstraint(err.constraint) ?? "",
-					message: err.detail ?? err.message
-				}]);
-				if (err.code === "23503") throw new _atscript_db.DbError("FK_VIOLATION", this._mapFkError(err.detail ?? err.message, err.constraint));
-			}
-			throw error;
+			return this._mapConstraintError(error);
+		}
+	}
+	/** Rethrows `error` as a structured `DbError` when it is a unique / FK violation, else as is. */
+	_mapConstraintError(error) {
+		if (error && typeof error === "object" && "code" in error) {
+			const err = error;
+			if (err.code === "23505") throw new _atscript_db.DbError("CONFLICT", [{
+				path: this._extractFieldFromConstraint(err.constraint) ?? "",
+				message: err.detail ?? err.message
+			}]);
+			if (err.code === "23503") throw new _atscript_db.DbError("FK_VIOLATION", this._mapFkError(err.detail ?? err.message, err.constraint));
 		}
+		throw error;
 	}
 	_extractFieldFromConstraint(constraint) {
 		if (!constraint) return;
@@ -653,11 +777,9 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 			const tableName = this.resolveTableName();
 			const pkCols = this._pkColumns();
 			const returningSuffix = pkCols.length > 0 ? ` RETURNING ${pkCols.map((pk) => qi(pk)).join(", ")}` : "";
-			const columns = (0, _atscript_db_sql_tools.insertManyColumns)(data);
-			const maxRowsPerBatch = columns.length > 0 ? Math.floor(6e4 / columns.length) : data.length;
+			const { columns, batches } = (0, _atscript_db_sql_tools.chunkInsertRows)(data);
 			const allIds = [];
-			for (let offset = 0; offset < data.length; offset += maxRowsPerBatch) {
-				const batch = data.slice(offset, offset + maxRowsPerBatch);
+			for (const batch of batches) {
 				const insert = buildInsertMany(tableName, batch, columns);
 				const sql = insert.sql + returningSuffix;
 				const params = insert.params;
@@ -674,6 +796,56 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 			};
 		});
 	}
+	supportsInsertIgnore() {
+		return true;
+	}
+	/**
+	* Batched `INSERT … VALUES (…), (…) ON CONFLICT DO NOTHING RETURNING <pk +
+	* unique key columns>`: one statement per chunk (a conflict never raises, so
+	* the surrounding transaction survives). Skipped rows are the ones missing
+	* from RETURNING — mapped back by key values, see {@link mapIgnoredBatch}.
+	* Each chunk runs inside a SAVEPOINT: when the mapping is ambiguous (a key
+	* the server returns in another form than it was sent) the chunk is rolled
+	* back to the savepoint and redone row by row with the same
+	* `ON CONFLICT DO NOTHING`, so the result is always exact.
+	*/
+	async insertManyIgnore(data) {
+		if (data.length === 0) return [];
+		return this.withTransaction(async () => {
+			const tableName = this.resolveTableName();
+			const pkCols = this._pkColumns();
+			const keySets = this._table.uniqueKeySets;
+			const returning = [...new Set(keySets.flat())];
+			const returningCols = new Set(returning);
+			const nonTextKeyCols = new Set(this._table.fieldDescriptors.filter((f) => returningCols.has(f.physicalName) && !isTextKeyType(this.typeMapper(f))).map((f) => f.physicalName));
+			const returningSuffix = returning.length > 0 ? ` RETURNING ${returning.map((c) => qi(c)).join(", ")}` : "";
+			const insertedId = (row, returned) => ({ insertedId: this._resolveInsertedId(row, pkCols.length > 0 ? returned?.[pkCols[0]] : void 0) });
+			const { columns, batches } = (0, _atscript_db_sql_tools.chunkInsertRows)(data);
+			const slots = [];
+			for (const batch of batches) {
+				const insert = buildInsertMany(tableName, batch, columns);
+				const sql = `${insert.sql} ON CONFLICT DO NOTHING${returningSuffix}`;
+				await this._exec().run(`SAVEPOINT ${IGNORE_SAVEPOINT}`);
+				this._log(sql, insert.params);
+				const returned = (await this._wrapConstraintError(() => this._exec().run(sql, insert.params))).rows ?? [];
+				const mapping = returning.length === 0 ? batch.map((_, i) => i) : mapIgnoredBatch(batch, returned, keySets, nonTextKeyCols);
+				if (mapping) {
+					await this._exec().run(`RELEASE SAVEPOINT ${IGNORE_SAVEPOINT}`);
+					mapping.forEach((hit, i) => slots.push(hit < 0 ? null : insertedId(batch[i], returned[hit])));
+					continue;
+				}
+				await this._exec().run(`ROLLBACK TO SAVEPOINT ${IGNORE_SAVEPOINT}`);
+				for (const row of batch) {
+					const single = buildInsert(tableName, row);
+					const rowSql = `${single.sql} ON CONFLICT DO NOTHING${returningSuffix}`;
+					this._log(rowSql, single.params);
+					const rowResult = await this._wrapConstraintError(() => this._exec().run(rowSql, single.params));
+					slots.push(rowResult.rows?.length ? insertedId(row, rowResult.rows[0]) : null);
+				}
+			}
+			return slots;
+		});
+	}
 	async findOne(query) {
 		const where = buildWhere(query.filter);
 		const controls = {
@@ -716,28 +888,11 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 		if (query.controls.$count) {
 			const { sql, params } = buildAggregateCount(tableName, where, query.controls);
 			this._log(sql, params);
-			return [{ count: parseCount((await this._wrapBucketZoneError(() => this._exec().get(sql, params)))?.count) }];
+			return [{ count: parseCount((await (0, _atscript_db_sql_tools.mapQueryErrors)(pgDialect, () => this._exec().get(sql, params), query.controls))?.count) }];
 		}
 		const { sql, params } = buildAggregateSelect(tableName, where, query.controls);
 		this._log(sql, params);
-		return this._wrapBucketZoneError(() => this._exec().all(sql, params));
-	}
-	/**
-	* Maps PostgreSQL's unknown-zone error — SQLSTATE 22023
-	* (`invalid_parameter_value`), `time zone "…" not recognized` — raised by a
-	* calendar bucket's `AT TIME ZONE '<tz>'` to `BUCKET_TZ_UNAVAILABLE`. The
-	* zone passed the core's IANA validation, so the server's tz database is
-	* older than the runtime's. Other errors propagate unchanged.
-	*/
-	async _wrapBucketZoneError(fn) {
-		try {
-			return await fn();
-		} catch (error) {
-			const err = error;
-			const zone = err?.code === "22023" && typeof err.message === "string" ? /time zone "([^"]*)" not recognized/.exec(err.message)?.[1] : void 0;
-			if (zone !== void 0) throw (0, _atscript_db.bucketTimeZoneUnavailable)(`PostgreSQL does not recognize time zone "${zone}" — update the server's time zone data`);
-			throw error;
-		}
+		return (0, _atscript_db_sql_tools.mapQueryErrors)(pgDialect, () => this._exec().all(sql, params), query.controls);
 	}
 	/** Physical primary-key columns (`@db.column` renames applied). */
 	_pkColumns() {
@@ -1856,8 +2011,10 @@ var PgDriver = class {
 			}
 		};
 	}
-	async close() {
-		await (await this.getPool()).end();
+	_closing;
+	/** Idempotent: every call returns the first call's promise. */
+	close() {
+		return this._closing ??= Promise.resolve(this.getPool()).then((pool) => pool.end());
 	}
 };
 //#endregion
@@ -1874,7 +2031,7 @@ function createAdapter(uri, options) {
 		connectionString: uri,
 		...options
 	});
-	return new _atscript_db.DbSpace(() => new PostgresAdapter(driver));
+	return new _atscript_db.DbSpace(() => new PostgresAdapter(driver), { onClose: () => driver.close() });
 }
 //#endregion
 exports.PgDriver = PgDriver;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
+import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
 import { TMetadataMap } from "@atscript/typescript/utils";
 import { TFilterVisitorOptions, TSqlFragment } from "@atscript/db-sql-tools";
 
@@ -125,8 +125,10 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * server's tz database (an unknown one maps to `BUCKET_TZ_UNAVAILABLE`).
    */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
-  /** Every aggregate function, `countDistinct` included. */
+  /** Every aggregate function: `countDistinct`, `first` and `last` included. */
   aggregateFns(): ReadonlySet<AggregateFn>;
+  /** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+  supportsAggregateExpressions(): boolean;
   /** Computed view columns and first-row joins. */
   viewCapabilities(): ReadonlySet<TViewCapability>;
   onBeforeFlatten(_type: unknown): void;
@@ -149,10 +151,24 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * - 23503 = foreign_key_violation
    */
   private _wrapConstraintError;
+  /** Rethrows `error` as a structured `DbError` when it is a unique / FK violation, else as is. */
+  private _mapConstraintError;
   private _extractFieldFromConstraint;
   private _mapFkError;
   insertOne(data: Record<string, unknown>): Promise<TDbInsertResult>;
   insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
+  supportsInsertIgnore(): boolean;
+  /**
+   * Batched `INSERT … VALUES (…), (…) ON CONFLICT DO NOTHING RETURNING <pk +
+   * unique key columns>`: one statement per chunk (a conflict never raises, so
+   * the surrounding transaction survives). Skipped rows are the ones missing
+   * from RETURNING — mapped back by key values, see {@link mapIgnoredBatch}.
+   * Each chunk runs inside a SAVEPOINT: when the mapping is ambiguous (a key
+   * the server returns in another form than it was sent) the chunk is rolled
+   * back to the savepoint and redone row by row with the same
+   * `ON CONFLICT DO NOTHING`, so the result is always exact.
+   */
+  insertManyIgnore(data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
   findOne(query: DbQuery): Promise<Record<string, unknown> | null>;
   findMany(query: DbQuery): Promise<Array<Record<string, unknown>>>;
   /**
@@ -162,14 +178,6 @@ declare class PostgresAdapter extends BaseDbAdapter {
   findManyPerPartition(query: DbQuery, partitionBy: readonly string[]): Promise<Array<Record<string, unknown>>>;
   count(query: DbQuery): Promise<number>;
   aggregate(query: DbQuery): Promise<Array<Record<string, unknown>>>;
-  /**
-   * Maps PostgreSQL's unknown-zone error — SQLSTATE 22023
-   * (`invalid_parameter_value`), `time zone "…" not recognized` — raised by a
-   * calendar bucket's `AT TIME ZONE '<tz>'` to `BUCKET_TZ_UNAVAILABLE`. The
-   * zone passed the core's IANA validation, so the server's tz database is
-   * older than the runtime's. Other errors propagate unchanged.
-   */
-  private _wrapBucketZoneError;
   /** Physical primary-key columns (`@db.column` renames applied). */
   private _pkColumns;
   /**
@@ -345,6 +353,8 @@ declare class PgDriver implements TPgDriver {
   get<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T | null>;
   exec(sql: string): Promise<void>;
   getConnection(): Promise<TPgConnection>;
+  private _closing?;
+  /** Idempotent: every call returns the first call's promise. */
   close(): Promise<void>;
 }
 //#endregion

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
+import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
 import { TFilterVisitorOptions, TSqlFragment } from "@atscript/db-sql-tools";
 import { TMetadataMap } from "@atscript/typescript/utils";
 
@@ -125,8 +125,10 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * server's tz database (an unknown one maps to `BUCKET_TZ_UNAVAILABLE`).
    */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
-  /** Every aggregate function, `countDistinct` included. */
+  /** Every aggregate function: `countDistinct`, `first` and `last` included. */
   aggregateFns(): ReadonlySet<AggregateFn>;
+  /** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+  supportsAggregateExpressions(): boolean;
   /** Computed view columns and first-row joins. */
   viewCapabilities(): ReadonlySet<TViewCapability>;
   onBeforeFlatten(_type: unknown): void;
@@ -149,10 +151,24 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * - 23503 = foreign_key_violation
    */
   private _wrapConstraintError;
+  /** Rethrows `error` as a structured `DbError` when it is a unique / FK violation, else as is. */
+  private _mapConstraintError;
   private _extractFieldFromConstraint;
   private _mapFkError;
   insertOne(data: Record<string, unknown>): Promise<TDbInsertResult>;
   insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
+  supportsInsertIgnore(): boolean;
+  /**
+   * Batched `INSERT … VALUES (…), (…) ON CONFLICT DO NOTHING RETURNING <pk +
+   * unique key columns>`: one statement per chunk (a conflict never raises, so
+   * the surrounding transaction survives). Skipped rows are the ones missing
+   * from RETURNING — mapped back by key values, see {@link mapIgnoredBatch}.
+   * Each chunk runs inside a SAVEPOINT: when the mapping is ambiguous (a key
+   * the server returns in another form than it was sent) the chunk is rolled
+   * back to the savepoint and redone row by row with the same
+   * `ON CONFLICT DO NOTHING`, so the result is always exact.
+   */
+  insertManyIgnore(data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
   findOne(query: DbQuery): Promise<Record<string, unknown> | null>;
   findMany(query: DbQuery): Promise<Array<Record<string, unknown>>>;
   /**
@@ -162,14 +178,6 @@ declare class PostgresAdapter extends BaseDbAdapter {
   findManyPerPartition(query: DbQuery, partitionBy: readonly string[]): Promise<Array<Record<string, unknown>>>;
   count(query: DbQuery): Promise<number>;
   aggregate(query: DbQuery): Promise<Array<Record<string, unknown>>>;
-  /**
-   * Maps PostgreSQL's unknown-zone error — SQLSTATE 22023
-   * (`invalid_parameter_value`), `time zone "…" not recognized` — raised by a
-   * calendar bucket's `AT TIME ZONE '<tz>'` to `BUCKET_TZ_UNAVAILABLE`. The
-   * zone passed the core's IANA validation, so the server's tz database is
-   * older than the runtime's. Other errors propagate unchanged.
-   */
-  private _wrapBucketZoneError;
   /** Physical primary-key columns (`@db.column` renames applied). */
   private _pkColumns;
   /**
@@ -345,6 +353,8 @@ declare class PgDriver implements TPgDriver {
   get<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T | null>;
   exec(sql: string): Promise<void>;
   getConnection(): Promise<TPgConnection>;
+  private _closing?;
+  /** Idempotent: every call returns the first call's promise. */
   close(): Promise<void>;
 }
 //#endregion

package/dist/index.mjs

@@ -1,7 +1,78 @@
-import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, ALL_VIEW_CAPABILITIES, BaseDbAdapter, DbError, DbSpace, bucketTimeZoneUnavailable, fkColumns, isColumnTypeChanged, vectorIndexNotFoundMessage } from "@atscript/db";
+import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, ALL_VIEW_CAPABILITIES, BaseDbAdapter, DbError, DbSpace, bucketTimeZoneUnavailable, fkColumns, isColumnTypeChanged, uniqueKeyTuple, vectorIndexNotFoundMessage } from "@atscript/db";
 import { resolveAggregateSearch } from "@atscript/db/agg";
-import { SEARCH_SOURCE_ALIAS, buildAggregateCount, buildAggregateSelect, buildCreateView, buildDelete, buildGeoSearchCount, buildGeoSearchSelect, buildInsert, buildInsertMany, buildPartitionedSelect, buildSelect, buildUpdate, buildVectorSearchCount, buildVectorSearchSelect, buildWhere as buildWhere$1, defaultValueForType, defaultValueToSqlLiteral, derivedColumnExpr, fillReplacePayload, finalizeParams, foreignKeySql, geoWindowFromControls, insertManyColumns, normalizeGeoPointValue, parseRegexString, quotedJsonPathSegments, renameGeoDistance, replaceColumnsFor, sqlStringLiteral, sqlTimeZoneLiteral, stripPartitionRowNumber, vectorDistanceSource } from "@atscript/db-sql-tools";
+import { SEARCH_SOURCE_ALIAS, arithOverflowError, buildAggregateCount, buildAggregateSelect, buildCreateView, buildDelete, buildGeoSearchCount, buildGeoSearchSelect, buildInsert, buildInsertMany, buildPartitionedSelect, buildSelect, buildUpdate, buildVectorSearchCount, buildVectorSearchSelect, buildWhere as buildWhere$1, chunkInsertRows, defaultValueForType, defaultValueToSqlLiteral, derivedColumnExpr, fillReplacePayload, finalizeParams, foreignKeySql, geoWindowFromControls, mapQueryErrors, normalizeGeoPointValue, numericOutOfRangeError, parseRegexString, quotedJsonPathSegments, renameGeoDistance, replaceColumnsFor, sqlStringLiteral, sqlTimeZoneLiteral, stripPartitionRowNumber, vectorDistanceSource } from "@atscript/db-sql-tools";
 import { BUCKET_MAX_INSTANT, BUCKET_MIN_INSTANT } from "@uniqu/core";
+//#region src/insert-ignore.ts
+/**
+* Whether two key values are the same value written differently: a number
+* and its decimal text (`5` / `"5.00"` of a NUMERIC column), a string and its
+* blank-padded form (`"ab"` / `"ab   "` of a CHAR(n) column), or in another
+* letter case (`uuid`, `citext`).
+*/
+function looselySame(a, b) {
+	const textA = typeof a === "number" || typeof a === "string" ? `${a}` : void 0;
+	const textB = typeof b === "number" || typeof b === "string" ? `${b}` : void 0;
+	if (textA === void 0 || textB === void 0) return false;
+	const na = Number(textA);
+	const nb = Number(textB);
+	if (textA.trim() !== "" && textB.trim() !== "" && Number.isFinite(na) && na === nb) return true;
+	return typeof a === "string" && typeof b === "string" && a.trimEnd().toLowerCase() === b.trimEnd().toLowerCase();
+}
+/** A key value the server may store in another form than it was sent (NUMERIC / decimal rounding). */
+function mayNormalize(value, col, formCols) {
+	if (typeof value === "string" && col !== void 0 && formCols?.has(col)) return true;
+	return typeof value === "number" && !Number.isInteger(value) || typeof value === "string" && /^-?\d+\.\d+$/.test(value);
+}
+/**
+* Maps the rows a batched `INSERT … ON CONFLICT DO NOTHING RETURNING <keys>`
+* returned back to the batch's input rows.
+*
+* PostgreSQL returns the inserted rows in VALUES order and omits skipped ones,
+* so `returned` is an in-order subsequence of `batch`. A row is inserted
+* exactly when the next returned row carries EVERY key set the row fully
+* defines (key sets with an absent / null input component are never compared:
+* a generated key's value is unknown to the input). Result: per input row, the
+* index of its returned row, or `-1` when it was skipped.
+*
+* `undefined` when the mapping is not provably exact — a row that defines no
+* complete key set (it may match a returned row only by a generated value), a
+* skipped-looking row whose key a server could have normalized (non-integer
+* numbers / decimals), a key equal to the returned one only when written
+* differently (`5` / `"5.00"`, blank-padded CHAR, a `uuid` / `citext` in another
+* letter case — the server lower-cases a returned uuid, so `"AAA"` / `"aaa"` could
+* swap the mapping), or returned rows left unaccounted for (counts or keys that
+* do not line up with an in-order subsequence). The caller must then redo the
+* chunk row by row. An empty `returned` (everything skipped) and a fully-returned
+* batch (everything inserted) are exact without any matching.
+*
+* @param keySets Physical column names of the primary key and every unique index.
+* @param formCols Key columns whose physical type is not text (uuid, inet, cidr,
+*   macaddr, …, `@db.pg.type` overrides): a string key there may come back
+*   normalized, so a skipped-looking row of such a key is ambiguous.
+*/
+function mapIgnoredBatch(batch, returned, keySets, formCols) {
+	if (returned.length === 0) return batch.map(() => -1);
+	if (returned.length === batch.length) return batch.map((_, i) => i);
+	const out = [];
+	let next = 0;
+	for (const row of batch) {
+		const tuples = keySets.map((cols) => uniqueKeyTuple(row, cols));
+		if (tuples.every((t) => t === void 0)) return void 0;
+		const candidate = returned[next];
+		if (candidate !== void 0) {
+			const strict = keySets.map((cols, k) => tuples[k] === void 0 || tuples[k] === uniqueKeyTuple(candidate, cols));
+			if (strict.every(Boolean)) {
+				out.push(next++);
+				continue;
+			}
+			if (keySets.every((cols, k) => tuples[k] === void 0 || strict[k] || cols.every((c) => looselySame(row[c], candidate[c])))) return void 0;
+		}
+		if (keySets.some((cols, k) => tuples[k] !== void 0 && cols.some((c) => mayNormalize(row[c], c, formCols)))) return;
+		out.push(-1);
+	}
+	return next === returned.length ? out : void 0;
+}
+//#endregion
 //#region src/sql-builder.ts
 /**
 * PostgreSQL-aware default value for a given design type.
@@ -79,6 +150,25 @@ const pgDialect = {
 	calendarBucket: pgCalendarBucket,
 	jsonExtract: pgJsonExtract,
 	castDouble: (expr) => `CAST(${expr} AS DOUBLE PRECISION)`,
+	anyValue: pgAnyValue,
+	booleanAggregates: {
+		min: "BOOL_AND",
+		max: "BOOL_OR"
+	},
+	/**
+	* SQLSTATE 22003 (`numeric_value_out_of_range`), a double overflow in
+	* aggregate arithmetic, is `INVALID_QUERY`; SQLSTATE 22023
+	* (`invalid_parameter_value`, `time zone "…" not recognized`), raised by a
+	* calendar bucket's `AT TIME ZONE '<tz>'`, is `BUCKET_TZ_UNAVAILABLE` — the
+	* zone passed the core's IANA validation, so the server's tz database is
+	* older than the runtime's.
+	*/
+	mapQueryError(error, arithmetic) {
+		const err = error;
+		if (err?.code === "22003") return arithmetic ? arithOverflowError() : numericOutOfRangeError();
+		const zone = err?.code === "22023" && typeof err.message === "string" ? /time zone "([^"]*)" not recognized/.exec(err.message)?.[1] : void 0;
+		return zone === void 0 ? void 0 : bucketTimeZoneUnavailable(`PostgreSQL does not recognize time zone "${zone}" — update the server's time zone data`);
+	},
 	nullsSortLargest: true,
 	createViewPrefix: "CREATE OR REPLACE VIEW",
 	paramPlaceholder(index) {
@@ -256,6 +346,30 @@ function intTypeFromTags(tags) {
 	if (tags?.has("int64") || tags?.has("uint64")) return "BIGINT";
 	return "INTEGER";
 }
+/** Physical types `MIN` aggregates (base name, lower-cased): the streaming pick applies. */
+const MIN_ORDERED_TYPE = /^(smallint|int2|integer|int|int4|bigint|int8|real|float4|double precision|float8|numeric|decimal|money|text|varchar|character varying|char|character|bpchar|date|time|timetz|timestamp|timestamptz|interval|time (with|without) time zone|timestamp (with|without) time zone)\b/;
+/** Text key types: a value comes back in the form it was sent (modulo case for `citext`), so a returned key maps to its input row. */
+const TEXT_KEY_TYPE = /^(text|varchar|character varying|char|character|bpchar|citext)\b/;
+/** `true` when the physical column type `type` is a text type (see {@link TEXT_KEY_TYPE}). */
+function isTextKeyType(type) {
+	return TEXT_KEY_TYPE.test(type.trim().toLowerCase());
+}
+/**
+* The "any value of the group" pick of a `first` / `last` derived column
+* (constant within its group) over a PostgreSQL column: `MIN` (streaming — one
+* accumulator per group) for the ordered types and for every array column
+* (`MIN(anyarray)`; `ARRAY_AGG` over arrays builds a 2-D array and rejects NULL /
+* empty ones), `BOOL_AND` for a boolean, and `(ARRAY_AGG(x))[1]` only where the
+* physical type has no `MIN` (uuid, bytea, point, json / jsonb, citext,
+* `@db.pg.type` overrides, …) or is unknown.
+*/
+function pgAnyValue(expr, field) {
+	const type = field ? pgTypeFromField(field).trim().toLowerCase() : "";
+	if (type.endsWith("[]")) return `MIN(${expr})`;
+	if (/^bool(ean)?\b/.test(type)) return `BOOL_AND(${expr})`;
+	if (MIN_ORDERED_TYPE.test(type)) return `MIN(${expr})`;
+	return `(ARRAY_AGG(${expr}))[1]`;
+}
 /**
 * Maps an Atscript field descriptor to a PostgreSQL column type.
 *
@@ -311,11 +425,11 @@ function buildCreateTable(table, fields, foreignKeys, options) {
 			continue;
 		}
 		let def = `${qi(field.physicalName)} ${sqlType}`;
-		if (options?.incrementFields?.has(field.physicalName)) {
+		if (options?.incrementFields?.has(field.path)) {
 			const start = options.autoIncrementStart;
 			def += start !== void 0 ? ` GENERATED BY DEFAULT AS IDENTITY (START WITH ${start})` : " GENERATED BY DEFAULT AS IDENTITY";
 		}
-		if (!field.optional && !field.isPrimaryKey && !options?.incrementFields?.has(field.physicalName)) def += " NOT NULL";
+		if (!field.optional && !field.isPrimaryKey && !options?.incrementFields?.has(field.path)) def += " NOT NULL";
 		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${defaultValueToSqlLiteral$1(field.designType, field.defaultValue.value)}`;
 		else if (field.defaultValue?.kind === "fn") {
 			if (field.defaultValue.fn === "uuid") def += " DEFAULT gen_random_uuid()";
@@ -385,6 +499,8 @@ function parseCount(value) {
 * ```
 */
 /** The suffix PostgreSQL gives an auto-named constraint of each `pg_constraint.contype`. */
+/** Savepoint guarding one `insertManyIgnore` chunk (see {@link PostgresAdapter.insertManyIgnore}). */
+const IGNORE_SAVEPOINT = "atscript_ignore_chunk";
 const PG_CONSTRAINT_LABELS = {
 	p: "pkey",
 	u: "key",
@@ -527,10 +643,14 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	calendarBucketUnits() {
 		return ALL_BUCKET_UNITS;
 	}
-	/** Every aggregate function, `countDistinct` included. */
+	/** Every aggregate function: `countDistinct`, `first` and `last` included. */
 	aggregateFns() {
 		return ALL_AGGREGATE_FNS;
 	}
+	/** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+	supportsAggregateExpressions() {
+		return true;
+	}
 	/** Computed view columns and first-row joins. */
 	viewCapabilities() {
 		return ALL_VIEW_CAPABILITIES;
@@ -600,16 +720,20 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 		try {
 			return await fn();
 		} catch (error) {
-			if (error && typeof error === "object" && "code" in error) {
-				const err = error;
-				if (err.code === "23505") throw new DbError("CONFLICT", [{
-					path: this._extractFieldFromConstraint(err.constraint) ?? "",
-					message: err.detail ?? err.message
-				}]);
-				if (err.code === "23503") throw new DbError("FK_VIOLATION", this._mapFkError(err.detail ?? err.message, err.constraint));
-			}
-			throw error;
+			return this._mapConstraintError(error);
+		}
+	}
+	/** Rethrows `error` as a structured `DbError` when it is a unique / FK violation, else as is. */
+	_mapConstraintError(error) {
+		if (error && typeof error === "object" && "code" in error) {
+			const err = error;
+			if (err.code === "23505") throw new DbError("CONFLICT", [{
+				path: this._extractFieldFromConstraint(err.constraint) ?? "",
+				message: err.detail ?? err.message
+			}]);
+			if (err.code === "23503") throw new DbError("FK_VIOLATION", this._mapFkError(err.detail ?? err.message, err.constraint));
 		}
+		throw error;
 	}
 	_extractFieldFromConstraint(constraint) {
 		if (!constraint) return;
@@ -652,11 +776,9 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			const tableName = this.resolveTableName();
 			const pkCols = this._pkColumns();
 			const returningSuffix = pkCols.length > 0 ? ` RETURNING ${pkCols.map((pk) => qi(pk)).join(", ")}` : "";
-			const columns = insertManyColumns(data);
-			const maxRowsPerBatch = columns.length > 0 ? Math.floor(6e4 / columns.length) : data.length;
+			const { columns, batches } = chunkInsertRows(data);
 			const allIds = [];
-			for (let offset = 0; offset < data.length; offset += maxRowsPerBatch) {
-				const batch = data.slice(offset, offset + maxRowsPerBatch);
+			for (const batch of batches) {
 				const insert = buildInsertMany$1(tableName, batch, columns);
 				const sql = insert.sql + returningSuffix;
 				const params = insert.params;
@@ -673,6 +795,56 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			};
 		});
 	}
+	supportsInsertIgnore() {
+		return true;
+	}
+	/**
+	* Batched `INSERT … VALUES (…), (…) ON CONFLICT DO NOTHING RETURNING <pk +
+	* unique key columns>`: one statement per chunk (a conflict never raises, so
+	* the surrounding transaction survives). Skipped rows are the ones missing
+	* from RETURNING — mapped back by key values, see {@link mapIgnoredBatch}.
+	* Each chunk runs inside a SAVEPOINT: when the mapping is ambiguous (a key
+	* the server returns in another form than it was sent) the chunk is rolled
+	* back to the savepoint and redone row by row with the same
+	* `ON CONFLICT DO NOTHING`, so the result is always exact.
+	*/
+	async insertManyIgnore(data) {
+		if (data.length === 0) return [];
+		return this.withTransaction(async () => {
+			const tableName = this.resolveTableName();
+			const pkCols = this._pkColumns();
+			const keySets = this._table.uniqueKeySets;
+			const returning = [...new Set(keySets.flat())];
+			const returningCols = new Set(returning);
+			const nonTextKeyCols = new Set(this._table.fieldDescriptors.filter((f) => returningCols.has(f.physicalName) && !isTextKeyType(this.typeMapper(f))).map((f) => f.physicalName));
+			const returningSuffix = returning.length > 0 ? ` RETURNING ${returning.map((c) => qi(c)).join(", ")}` : "";
+			const insertedId = (row, returned) => ({ insertedId: this._resolveInsertedId(row, pkCols.length > 0 ? returned?.[pkCols[0]] : void 0) });
+			const { columns, batches } = chunkInsertRows(data);
+			const slots = [];
+			for (const batch of batches) {
+				const insert = buildInsertMany$1(tableName, batch, columns);
+				const sql = `${insert.sql} ON CONFLICT DO NOTHING${returningSuffix}`;
+				await this._exec().run(`SAVEPOINT ${IGNORE_SAVEPOINT}`);
+				this._log(sql, insert.params);
+				const returned = (await this._wrapConstraintError(() => this._exec().run(sql, insert.params))).rows ?? [];
+				const mapping = returning.length === 0 ? batch.map((_, i) => i) : mapIgnoredBatch(batch, returned, keySets, nonTextKeyCols);
+				if (mapping) {
+					await this._exec().run(`RELEASE SAVEPOINT ${IGNORE_SAVEPOINT}`);
+					mapping.forEach((hit, i) => slots.push(hit < 0 ? null : insertedId(batch[i], returned[hit])));
+					continue;
+				}
+				await this._exec().run(`ROLLBACK TO SAVEPOINT ${IGNORE_SAVEPOINT}`);
+				for (const row of batch) {
+					const single = buildInsert$1(tableName, row);
+					const rowSql = `${single.sql} ON CONFLICT DO NOTHING${returningSuffix}`;
+					this._log(rowSql, single.params);
+					const rowResult = await this._wrapConstraintError(() => this._exec().run(rowSql, single.params));
+					slots.push(rowResult.rows?.length ? insertedId(row, rowResult.rows[0]) : null);
+				}
+			}
+			return slots;
+		});
+	}
 	async findOne(query) {
 		const where = buildWhere(query.filter);
 		const controls = {
@@ -715,28 +887,11 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 		if (query.controls.$count) {
 			const { sql, params } = buildAggregateCount$1(tableName, where, query.controls);
 			this._log(sql, params);
-			return [{ count: parseCount((await this._wrapBucketZoneError(() => this._exec().get(sql, params)))?.count) }];
+			return [{ count: parseCount((await mapQueryErrors(pgDialect, () => this._exec().get(sql, params), query.controls))?.count) }];
 		}
 		const { sql, params } = buildAggregateSelect$1(tableName, where, query.controls);
 		this._log(sql, params);
-		return this._wrapBucketZoneError(() => this._exec().all(sql, params));
-	}
-	/**
-	* Maps PostgreSQL's unknown-zone error — SQLSTATE 22023
-	* (`invalid_parameter_value`), `time zone "…" not recognized` — raised by a
-	* calendar bucket's `AT TIME ZONE '<tz>'` to `BUCKET_TZ_UNAVAILABLE`. The
-	* zone passed the core's IANA validation, so the server's tz database is
-	* older than the runtime's. Other errors propagate unchanged.
-	*/
-	async _wrapBucketZoneError(fn) {
-		try {
-			return await fn();
-		} catch (error) {
-			const err = error;
-			const zone = err?.code === "22023" && typeof err.message === "string" ? /time zone "([^"]*)" not recognized/.exec(err.message)?.[1] : void 0;
-			if (zone !== void 0) throw bucketTimeZoneUnavailable(`PostgreSQL does not recognize time zone "${zone}" — update the server's time zone data`);
-			throw error;
-		}
+		return mapQueryErrors(pgDialect, () => this._exec().all(sql, params), query.controls);
 	}
 	/** Physical primary-key columns (`@db.column` renames applied). */
 	_pkColumns() {
@@ -1855,8 +2010,10 @@ var PgDriver = class {
 			}
 		};
 	}
-	async close() {
-		await (await this.getPool()).end();
+	_closing;
+	/** Idempotent: every call returns the first call's promise. */
+	close() {
+		return this._closing ??= Promise.resolve(this.getPool()).then((pool) => pool.end());
 	}
 };
 //#endregion
@@ -1873,7 +2030,7 @@ function createAdapter(uri, options) {
 		connectionString: uri,
 		...options
 	});
-	return new DbSpace(() => new PostgresAdapter(driver));
+	return new DbSpace(() => new PostgresAdapter(driver), { onClose: () => driver.close() });
 }
 //#endregion
 export { PgDriver, PostgresAdapter, buildWhere, createAdapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db-postgres",
-  "version": "0.1.147",
+  "version": "0.1.148",
   "description": "PostgreSQL adapter for @atscript/db with pg (node-postgres) driver support.",
   "keywords": [
     "atscript",
@@ -43,20 +43,20 @@
     "access": "public"
   },
   "devDependencies": {
-    "@atscript/core": "^0.1.99",
-    "@atscript/typescript": "^0.1.99",
+    "@atscript/core": "^0.1.100",
+    "@atscript/typescript": "^0.1.100",
     "@types/pg": "^8.11.0",
-    "@uniqu/core": "^0.1.12",
+    "@uniqu/core": "^0.1.13",
     "pg": "^8.13.0",
-    "unplugin-atscript": "^0.1.99"
+    "unplugin-atscript": "^0.1.100"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.99",
-    "@atscript/typescript": "^0.1.99",
-    "@uniqu/core": "^0.1.12",
+    "@atscript/core": "^0.1.100",
+    "@atscript/typescript": "^0.1.100",
+    "@uniqu/core": "^0.1.13",
     "pg": ">=8.0.0",
-    "@atscript/db": "^0.1.147",
-    "@atscript/db-sql-tools": "^0.1.147"
+    "@atscript/db": "^0.1.148",
+    "@atscript/db-sql-tools": "^0.1.148"
   },
   "peerDependenciesMeta": {
     "pg": {