uql-orm 0.81.0 → 0.82.0

package/dist/migrate/acquireQuerierForMigrations.js

@@ -1,4 +1,5 @@
 import { isMongoQuerier, isSqlQuerier, } from '../type/index.js';
+import { UqlUsageError } from '../util/uqlError.js';
 /**
  * Querier used for schema migrations and the migration journal.
  *
@@ -34,7 +35,7 @@ export function withMongoQuerierForMigrations(pool, requiredBy, task) {
 function withQuerierOfKind(pool, isKind, error, task) {
     return withQuerierForMigrations(pool, (querier) => {
         if (!isKind(querier)) {
-            throw new TypeError(error);
+            throw new UqlUsageError(error);
         }
         return task(querier);
     });

package/dist/migrate/assertCliConfig.js

@@ -1,30 +1,31 @@
+import { UqlUsageError } from '../util/uqlError.js';
 /**
  * Validates shape required for the migrations CLI (real `QuerierPool`, not config stubs).
  */
 export function assertCliConfig(config) {
     if (config === null || typeof config !== 'object') {
-        throw new TypeError('Config must be a non-null object');
+        throw new UqlUsageError('Config must be a non-null object');
     }
     const c = config;
     const pool = c['pool'];
     if (pool === null || typeof pool !== 'object') {
-        throw new TypeError('Config.pool is required and must be an object');
+        throw new UqlUsageError('Config.pool is required and must be an object');
     }
     const p = pool;
     for (const key of ['getQuerier', 'transaction', 'withQuerier']) {
         if (typeof p[key] !== 'function') {
-            throw new TypeError(`Config.pool.${key} must be a function`);
+            throw new UqlUsageError(`Config.pool.${key} must be a function`);
         }
     }
     if (p['end'] !== undefined && typeof p['end'] !== 'function') {
-        throw new TypeError('Config.pool.end must be a function when provided');
+        throw new UqlUsageError('Config.pool.end must be a function when provided');
     }
     const dialect = p['dialect'];
     if (dialect === null || typeof dialect !== 'object') {
-        throw new TypeError('Config.pool.dialect is required and must be an object');
+        throw new UqlUsageError('Config.pool.dialect is required and must be an object');
     }
     const dialectName = dialect['dialectName'];
     if (typeof dialectName !== 'string') {
-        throw new TypeError('Config.pool.dialect.dialectName must be a string');
+        throw new UqlUsageError('Config.pool.dialect.dialectName must be a string');
     }
 }

package/dist/migrate/builder/expressions.js

@@ -1,3 +1,4 @@
+import { UqlUsageError } from '../../util/uqlError.js';
 const ANSI = {
     now: 'CURRENT_TIMESTAMP',
     currentDate: 'CURRENT_DATE',
@@ -129,7 +130,7 @@ function expressionSql(expression, dialect) {
     const { expressions } = DIALECT_DEFAULTS[dialect.dialectName];
     const sql = expression.kind === 'raw' ? expression.sql : expressions[expression.kind];
     if (sql == null) {
-        throw new TypeError(`${dialect.dialectName} has no '${expression.kind}' default; pass expr.raw(...) with SQL this engine accepts`);
+        throw new UqlUsageError(`${dialect.dialectName} has no '${expression.kind}' default; pass expr.raw(...) with SQL this engine accepts`);
     }
     return sql;
 }

package/dist/migrate/cli-config.js

@@ -1,13 +1,14 @@
 import { stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { UqlUsageError } from '../util/uqlError.js';
 /**
  * Loads the config with a plain `import()`, leaving TypeScript to the runtime: uql bundles no transpiler,
  * since only the project knows its decorator spec. Node's type stripping handles no decorators.
  */
 async function importConfig(path) {
     const mod = (await import(pathToFileURL(path).href).catch((cause) => {
-        throw new TypeError(`Could not import ${path}: ${cause?.message}\n` +
+        throw new UqlUsageError(`Could not import ${path}: ${cause?.message}\n` +
             'If it reaches entity classes, their decorators need a runtime that transforms TypeScript, not ' +
             'just one that strips its types. Run the CLI with `bun`, or with `node --import tsx` ' +
             '(`npm i -D tsx`). A JavaScript config, or passing the config inline, needs neither.', { cause });
@@ -21,14 +22,14 @@ export async function loadConfig(customPath) {
             .then(() => true)
             .catch(() => false);
         if (!exists) {
-            throw new TypeError(`Could not find uql configuration file at ${customPath}`);
+            throw new UqlUsageError(`Could not find uql configuration file at ${customPath}`);
         }
         try {
             const config = await importConfig(fullPath);
             return config;
         }
         catch (error) {
-            throw new TypeError(`Could not load configuration file at ${customPath}: ${error.message}`);
+            throw new UqlUsageError(`Could not load configuration file at ${customPath}: ${error.message}`);
         }
     }
     const configPaths = ['uql.config.ts', 'uql.config.js', 'uql.config.mjs', '.uqlrc.ts', '.uqlrc.js'];
@@ -42,5 +43,5 @@ export async function loadConfig(customPath) {
             return config;
         }
     }
-    throw new TypeError('Could not find uql configuration file. Create a uql.config.ts or uql.config.js file in your project root.');
+    throw new UqlUsageError('Could not find uql configuration file. Create a uql.config.ts or uql.config.js file in your project root.');
 }

package/dist/migrate/ddl/indexDdl.js

@@ -2,6 +2,7 @@ import { jsonTypeMode } from '../../dialect/jsonSql.js';
 import { INDEX_TYPES } from '../../schema/types.js';
 import { INDEX_FEATURE_LABELS, } from '../../type/index.js';
 import { fulltextConfig, getKeys } from '../../util/index.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 /**
  * What in an index asks for each feature. A `Record` over the feature union rather than a list, so a
  * feature added to {@link INDEX_FEATURE_LABELS} cannot reach a dialect without the test that decides
@@ -20,14 +21,14 @@ const INDEX_FEATURE_PROBES = {
 /** Refuses an index of a type `types` lacks, `hints` naming what to declare instead. */
 export function assertIndexType(index, types, dialectName, hints = new Map()) {
     if (index.type && !types.has(index.type)) {
-        throw new TypeError(`${dialectName} has no ${index.type} index (index "${index.name}")` + (hints.get(index.type) ?? ''));
+        throw new UqlUsageError(`${dialectName} has no ${index.type} index (index "${index.name}")` + (hints.get(index.type) ?? ''));
     }
 }
 /** Refuses an index asking for a feature `features` lacks. */
 export function assertIndexFeatures(index, features, dialectName) {
     for (const feature of getKeys(INDEX_FEATURE_PROBES)) {
         if (INDEX_FEATURE_PROBES[feature](index) && !features.has(feature)) {
-            throw new TypeError(`${dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
+            throw new UqlUsageError(`${dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
         }
     }
 }
@@ -122,7 +123,7 @@ export class IndexDdl {
      * every other dialect refuses `jsonArray` in {@link assertIndexFeatures} and never reaches this.
      */
     jsonArrayIndexExpr(_escapedColumn, _json) {
-        throw new TypeError(`${this.dialect.dialectName} has no multi-valued index`);
+        throw new UqlUsageError(`${this.dialect.dialectName} has no multi-valued index`);
     }
     /** Postgres-wire dialects put a vector or user-declared operator class here. */
     indexColumnOpsClass(_entry, _index) {

package/dist/migrate/ddl/mysqlIndexDdl.js

@@ -1,5 +1,6 @@
 import { jsonTypeMode } from '../../dialect/jsonSql.js';
 import { indexDistance, isVectorIndexType, unsupportedVectorMetric, VECTOR_INDEX_TYPES } from '../../type/vector.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { IndexDdl } from './indexDdl.js';
 /**
  * A full-text index is its own keyword here (`CREATE FULLTEXT INDEX ... (cols)`); `USING fulltext` is
@@ -38,14 +39,14 @@ export class MySqlIndexDdl extends MysqlLikeIndexDdl {
     jsonPathIndexExpr(escapedColumn, json) {
         const mode = jsonTypeMode(json.type);
         if (mode === 'json') {
-            throw new TypeError(`mysql cannot index the boolean JSON path '${json.path}', which compares as JSON`);
+            throw new UqlUsageError(`mysql cannot index the boolean JSON path '${json.path}', which compares as JSON`);
         }
         const expr = super.jsonPathIndexExpr(escapedColumn, json);
         if (mode === 'numeric') {
             return expr;
         }
         if (!json.length) {
-            throw new TypeError(`a MySQL index over the string JSON path '${json.path}' needs a length`);
+            throw new UqlUsageError(`a MySQL index over the string JSON path '${json.path}' needs a length`);
         }
         return `CAST(${expr} AS CHAR(${json.length}) CHARACTER SET utf8mb4) COLLATE utf8mb4_bin`;
     }
@@ -132,13 +133,13 @@ function arrayCastType(json) {
     const type = json.type;
     const cast = ARRAY_CASTS.get(typeof type === 'string' ? type.toLowerCase() : type);
     if (!cast) {
-        throw new TypeError(`mysql has no array cast for ${typeof type === 'string' ? type : type.name} elements`);
+        throw new UqlUsageError(`mysql has no array cast for ${typeof type === 'string' ? type : type.name} elements`);
     }
     if (cast !== 'CHAR' && cast !== 'BINARY') {
         return cast;
     }
     if (!json.length) {
-        throw new TypeError(`a multi-valued index over ${cast === 'CHAR' ? 'string' : 'binary'} elements needs a length`);
+        throw new UqlUsageError(`a multi-valued index over ${cast === 'CHAR' ? 'string' : 'binary'} elements needs a length`);
     }
     return `${cast}(${json.length})`;
 }

package/dist/migrate/ddl/pgIndexDdl.js

@@ -1,4 +1,5 @@
 import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { IndexDdl } from './indexDdl.js';
 /** `CREATE INDEX ... USING hnsw ("embedding" vector_cosine_ops) WITH (m = ...)`, pgvector's form. */
 export class PgIndexDdl extends IndexDdl {
@@ -49,7 +50,7 @@ export class PgIndexDdl extends IndexDdl {
         const opsClass = `${vectorType}_${metric}_ops`;
         // IVFFlat has neither a sparsevec nor an L1 operator class; HNSW has all of them (pgvector 0.8.2).
         if (index.type === 'ivfflat' && (vectorType === 'sparsevec' || distance === 'l1')) {
-            throw new TypeError(`ivfflat has no ${opsClass} operator class (index "${index.name}"); use hnsw`);
+            throw new UqlUsageError(`ivfflat has no ${opsClass} operator class (index "${index.name}"); use hnsw`);
         }
         return ` ${opsClass}`;
     }

package/dist/migrate/ddl/sqliteIndexDdl.js

@@ -1,4 +1,5 @@
 import { indexDistance, isVectorIndexType, unsupportedVectorMetric } from '../../type/vector.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { IndexDdl } from './indexDdl.js';
 /**
  * SQLite's `CREATE INDEX`, which names no index type. A vector index is libSQL's DiskANN where the dialect
@@ -31,7 +32,7 @@ export class SqliteIndexDdl extends IndexDdl {
         }
         // Its tables are named after the index, unquoted: any other name fails with "unable to initialize diskann".
         if (!/^\w+$/.test(index.name) || index.entries.length !== 1) {
-            throw new TypeError(`libSQL names a vector index only by letters, digits and underscores, over one column (index "${index.name}")`);
+            throw new UqlUsageError(`libSQL names a vector index only by letters, digits and underscores, over one column (index "${index.name}")`);
         }
         return metric;
     }

package/dist/migrate/ddl/tableDdl.js

@@ -1,3 +1,4 @@
+import { UqlUsageError } from '../../util/uqlError.js';
 import { formatDefaultValue, sameDefault } from '../builder/expressions.js';
 /**
  * A column's type with the size it was read back with, unless its spelling already carries one:
@@ -39,7 +40,7 @@ export class TableDdl {
      */
     alterColumn(table, column, definition, from) {
         if (this.dialect.alterColumnSyntax === 'none') {
-            throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
+            throw new UqlUsageError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
                 `This database does not support ALTER COLUMN.`);
         }
         const target = this.dialect.escapeId(table);

package/dist/migrate/generator/mongoCommand.js

@@ -1,3 +1,4 @@
+import { UqlUsageError } from '../../util/uqlError.js';
 export function serializeMongoCommand(command) {
     return JSON.stringify(command);
 }
@@ -9,7 +10,7 @@ function parseMongoCommand(statement) {
     return JSON.parse(statement);
 }
 function unsupportedMongoCommand(statement) {
-    return new TypeError(`unsupported MongoDB migration command: ${statement}`);
+    return new UqlUsageError(`unsupported MongoDB migration command: ${statement}`);
 }
 /** Execute one emitted command. */
 export function runMongoCommand(db, statement) {

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -6,6 +6,7 @@ import { QueryRaw, } from '../../type/index.js';
 import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
 import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
 import { sides } from '../schemaChange.js';
@@ -30,7 +31,7 @@ export class MongoSchemaGenerator extends MongoDialect {
     }
     /** A collection has no SQL to render a check, a computed column or an index expression into. */
     compileDdl() {
-        throw new TypeError('mongodb has no SQL to render a check, a computed column or an index expression into');
+        throw new UqlUsageError('mongodb has no SQL to render a check, a computed column or an index expression into');
     }
     /**
      * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
@@ -84,7 +85,7 @@ export class MongoSchemaGenerator extends MongoDialect {
      */
     compileIndexPredicate(where, entity, indexName) {
         if (where instanceof QueryRaw) {
-            throw new TypeError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
+            throw new UqlUsageError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
         }
         assertIndexPredicate(where, this.dialectName, indexName);
         const filter = this.renderFilter(entity, where);
@@ -160,7 +161,7 @@ export class MongoSchemaGenerator extends MongoDialect {
         assertIndexFeatures(index, new Set(), this.dialectName);
         const [vector, ...filters] = index.entries;
         if (!vector || index.dimensions === undefined) {
-            throw new TypeError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
+            throw new UqlUsageError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
         }
         const distance = indexDistance(index);
         const similarity = ATLAS_SIMILARITY[distance];
@@ -192,7 +193,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             case 'createTable': {
                 const { name, columns, indexes } = operation.table;
                 if (columns.length) {
-                    throw new TypeError(`mongodb does not support columns in a migration (collection "${name}")`);
+                    throw new UqlUsageError(`mongodb does not support columns in a migration (collection "${name}")`);
                 }
                 return [
                     serializeMongoCommand({ action: 'createCollection', name }),
@@ -208,7 +209,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             case 'dropIndex':
                 return [this.generateDropIndex(operation.tableName, operation.indexName)];
             default:
-                throw new TypeError(`mongodb does not support ${operation.type} in a migration`);
+                throw new UqlUsageError(`mongodb does not support ${operation.type} in a migration`);
         }
     }
     diffSchema(entity, currentTable) {

package/dist/migrate/indexPredicate.js

@@ -1,5 +1,6 @@
 import { QueryRaw } from '../type/queryRaw.js';
 import { isOperatorObject } from '../util/object.util.js';
+import { UqlUsageError } from '../util/uqlError.js';
 /**
  * The `$where` a partial index takes, on the engines where that is less than a query's: SQL Server's
  * `CREATE INDEX` `<filter_predicate>` (comparisons and `IN` on plain columns, joined by `AND`), and
@@ -30,7 +31,7 @@ export function assertIndexPredicate(where, dialectName, indexName) {
 }
 /** What refusing any part of a partial index's predicate reports. */
 export function refusedIndexPredicate(dialectName, part, indexName) {
-    return new TypeError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
+    return new UqlUsageError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
 }
 /** The first part of `where` outside `grammar`, depth-first; a `raw` clause is left alone. */
 function refusedOperator(where, grammar) {

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,6 +1,7 @@
 import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
 import { isOwnedName } from '../../util/sql.util.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
@@ -73,7 +74,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     withSqlQuerier(task) {
         return this.pool.withQuerier((querier) => {
             if (!isSqlQuerier(querier)) {
-                throw new TypeError(`${this.constructor.name} requires a SQL-based querier`);
+                throw new UqlUsageError(`${this.constructor.name} requires a SQL-based querier`);
             }
             return task(querier);
         });

package/dist/migrate/introspection/mongoIntrospector.js

@@ -1,6 +1,7 @@
 import { textConfigOf } from '../../mongo/textLanguage.js';
 import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
 import { isMongoQuerier, } from '../../type/index.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 /** What a server without Atlas Search answers a search index command with. */
 const SEARCH_NOT_ENABLED = 31082;
 /**
@@ -80,7 +81,7 @@ export class MongoSchemaIntrospector {
     withDb(task) {
         return this.pool.withQuerier((querier) => {
             if (!isMongoQuerier(querier)) {
-                throw new TypeError('MongoSchemaIntrospector requires a MongoDB querier');
+                throw new UqlUsageError('MongoSchemaIntrospector requires a MongoDB querier');
             }
             return task(querier.db);
         });

package/dist/migrate/migrationTarget.js

@@ -1,4 +1,5 @@
 import { isMongoQuerier, isSqlQuerier, } from '../type/index.js';
+import { UqlUsageError } from '../util/uqlError.js';
 import { withMongoQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
 import { MigrationBuilder } from './builder/migrationBuilder.js';
 import { migrationSource } from './codegen/migrationFile.js';
@@ -46,5 +47,5 @@ export async function migrationBuilderFor(querier) {
     if (isMongoQuerier(querier)) {
         return new MigrationBuilder(await mongoSchemaGenerator(), mongoSession(querier).run);
     }
-    throw new TypeError('A migration builder needs a SQL or a MongoDB querier');
+    throw new UqlUsageError('A migration builder needs a SQL or a MongoDB querier');
 }

package/dist/migrate/migrator.js

@@ -5,6 +5,7 @@ import { getEntities, getMeta } from '../entity/index.js';
 import { SchemaAST } from '../schema/index.js';
 import { hasTriggers } from '../util/field.util.js';
 import { LoggerWrapper } from '../util/index.js';
+import { UqlUsageError } from '../util/uqlError.js';
 import { buildMigrationModule } from './codegen/migrationFile.js';
 import { introspectorFor } from './introspection/registry.js';
 import { migrationBuilderFor, migrationTargetFor } from './migrationTarget.js';
@@ -96,7 +97,7 @@ export class Migrator {
         if (options.to) {
             const toIndex = selected.findIndex((m) => m.name === options.to);
             if (toIndex === -1) {
-                throw new TypeError(`Migration '${options.to}' not found`);
+                throw new UqlUsageError(`Migration '${options.to}' not found`);
             }
             selected = selected.slice(0, toIndex + 1);
         }

package/dist/migrate/schemaGenerator.js

@@ -5,6 +5,7 @@ import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
 import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName, isOwnedName } from '../util/sql.util.js';
+import { UqlUsageError } from '../util/uqlError.js';
 import { sameDefault } from './builder/expressions.js';
 import { splitSqlStatements } from './builder/splitSqlStatements.js';
 import { indexDdlFor, tableDdlFor } from './ddl/index.js';
@@ -536,7 +537,7 @@ export class SqlSchemaGenerator {
     }
     generateAddForeignKeySql(tableName, foreignKey) {
         if (!this.features.foreignKeyAlter) {
-            throw new TypeError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
+            throw new UqlUsageError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
         }
         const constraint = this.foreignKeyConstraint(tableName, foreignKey, this.escapeId(foreignKey.references.table));
         return `ALTER TABLE ${this.escapeId(tableName)} ADD ${constraint};`;
@@ -566,7 +567,7 @@ export class SqlSchemaGenerator {
             return `ALTER TABLE ${table} DROP PRIMARY KEY;`;
         }
         if (!constraintName) {
-            throw new TypeError(`Cannot drop the primary key of "${tableName}": ${this.dialect} names the constraint, and ` +
+            throw new UqlUsageError(`Cannot drop the primary key of "${tableName}": ${this.dialect} names the constraint, and ` +
                 'introspection did not report a name for it.');
         }
         return `ALTER TABLE ${table} DROP CONSTRAINT ${this.escapeId(constraintName)};`;
@@ -579,7 +580,7 @@ export class SqlSchemaGenerator {
         if (!column.generatedAs || this.features.generatedColumnAdd) {
             return;
         }
-        throw new TypeError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
+        throw new UqlUsageError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
             `"${tableName}" - this database only accepts one in a CREATE TABLE. Drop \`stored\` to have the ` +
             'expression spliced into each statement instead, or recreate the table in a written migration.');
     }
@@ -587,7 +588,7 @@ export class SqlSchemaGenerator {
         if (this.features.primaryKeyAlter) {
             return;
         }
-        throw new TypeError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
+        throw new UqlUsageError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
             'for it. Recreate the table in a written migration.');
     }
 }

package/dist/migrate/triggerSql.d.ts

@@ -21,4 +21,4 @@ export declare function dropTrigger<E>(dialect: AbstractSqlDialect, meta: Entity
  * column. Generated rather than authored, so unlike an authored body it renders on every engine from
  * one declaration - and not at all on the MySQL family, whose columns stamp themselves.
  */
-export declare function stampTriggers<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];
+export declare function stampTriggers<E extends object>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];