@vibeorm/sql 4.1.0 → 4.3.0

package/dist/dialects/sqlite-row-rules.d.ts

@@ -0,0 +1,8 @@
+import type { SqlDialect } from "../dialect.ts";
+import type { EventRowRuleContext, RenderedRowRule } from "../row-rules.ts";
+/** Emit literal-only ABORT diagnostics and one unfiltered BEFORE trigger per event. */
+export declare function renderSqliteRowRule({ dialect, context }: {
+    readonly dialect: SqlDialect;
+    readonly context: EventRowRuleContext;
+}): RenderedRowRule;
+//# sourceMappingURL=sqlite-row-rules.d.ts.map

package/dist/dialects/sqlite-table-definition.d.ts

@@ -8,12 +8,32 @@ export type TableDefinitionParts = {
     readonly clauses: readonly string[];
     readonly suffix: string;
 };
-/** Extract a CREATE TABLE list with a quote-aware delimiter walk, not an expression parser. */
-export declare function tableDefinitionParts(params: {
-    sql: string;
+/** A source token with balanced-parenthesis depth and original byte boundaries. */
+export type TableDefinitionToken = {
+    readonly value: string;
+    readonly kind: "word" | "quoted" | "literal" | "symbol";
+    readonly start: number;
+    readonly end: number;
+    readonly depth: number;
+};
+/** Scan SQL delimiters without looking inside quoted strings, identifiers or comments. */
+export declare function tableDefinitionTokens({ sql, backslashEscapes }: {
+    readonly sql: string;
+    readonly backslashEscapes?: boolean;
+}): readonly TableDefinitionToken[];
+/** Extract a CREATE TABLE list with a quote/comment-aware delimiter walk. */
+export declare function tableDefinitionParts({ sql, backslashEscapes }: {
+    readonly sql: string;
+    readonly backslashEscapes?: boolean;
 }): TableDefinitionParts;
+/** Read column names for SQLite source and MySQL SHOW CREATE using the same lexer. */
+export declare function tableColumnClauses({ sql, backslashEscapes, mysql }: {
+    readonly sql: string;
+    readonly backslashEscapes?: boolean;
+    readonly mysql?: boolean;
+}): readonly SqliteColumnClause[];
 /** Return column clauses without rewriting any SQL inside them. */
-export declare function sqliteColumnClauses(params: {
-    sql: string;
+export declare function sqliteColumnClauses({ sql }: {
+    readonly sql: string;
 }): readonly SqliteColumnClause[];
 //# sourceMappingURL=sqlite-table-definition.d.ts.map

package/dist/generated-columns.d.ts

@@ -0,0 +1,18 @@
+import type { GeneratedColumnIR } from "@vibeorm/schema";
+import type { SqlDialect } from "./dialect.ts";
+/** SQL helper name for the canonical stored generation declaration. */
+export type GeneratedColumnDeclaration = GeneratedColumnIR;
+/** Source evidence; virtual storage is reported for the caller's admission check. */
+export type ExtractedGeneratedColumn = {
+    readonly expression: string;
+    readonly storage: "stored" | "virtual";
+    readonly columnSql: string;
+    /** Declaration prefix, including any type/charset/collation/nullability qualifiers. */
+    readonly typeSql: string;
+};
+/** Render trusted physical SQL without interpreting or rewriting its expression. */
+export declare function renderGeneratedColumnClause({ dialect, generated }: {
+    readonly dialect: SqlDialect;
+    readonly generated: GeneratedColumnDeclaration;
+}): string;
+//# sourceMappingURL=generated-columns.d.ts.map

package/dist/index-expressions.d.ts

@@ -0,0 +1,61 @@
+import type { Dialect, EnumIR, IndexIR, QualifiedSqlName } from "@vibeorm/schema";
+import type { SqlDialect } from "./dialect.ts";
+import type { PredicateModel } from "./predicate.ts";
+import type { RenderedQuery } from "./render.ts";
+/** Complete ordered physical keys; expression text has no key wrapper or direction. */
+export type IndexKeyOperand = {
+    readonly kind: "field";
+    readonly name: string;
+    readonly desc: boolean;
+    readonly decimal?: boolean;
+    readonly operatorClass?: QualifiedSqlName;
+} | {
+    readonly kind: "expression";
+    readonly text: string;
+    readonly desc: boolean;
+};
+/** Scratch statements only: sessions, normalization context and cleanup belong to migrate. */
+export type IndexExpressionProbeParams = {
+    readonly dialect: SqlDialect;
+    readonly operation: "context" | "clone" | "createIndex" | "read" | "drop";
+    readonly probe: {
+        readonly table: string;
+        readonly index: string;
+    };
+    readonly table?: QualifiedSqlName;
+    readonly keys?: readonly IndexKeyOperand[];
+    readonly unique?: boolean;
+    readonly definition?: string;
+    readonly backslashEscapes?: boolean;
+    readonly where?: string;
+    readonly nullsNotDistinct?: boolean;
+};
+/** Resolve logical terms using the shared scalar renderer, then qualify physical key storage. */
+export declare function resolveIndexKeys({ index, model, dialect, enums, site }: {
+    readonly index: IndexIR;
+    readonly model: PredicateModel;
+    readonly dialect: SqlDialect;
+    readonly enums?: readonly EnumIR[];
+    readonly site: string;
+}): readonly IndexKeyOperand[];
+/** Render complete key fragments; the caller owns the outer CREATE/ALTER list. */
+export declare function renderIndexKeys({ dialect, keys, unique }: {
+    readonly dialect: SqlDialect;
+    readonly keys: readonly IndexKeyOperand[];
+    readonly unique: boolean;
+}): readonly string[];
+/** Recover raw physical terms without inventing typed logical expressions or Decimal origin. */
+export declare function extractIndexKeys({ dialect, definition, index, backslashEscapes }: {
+    readonly dialect: Dialect;
+    readonly definition: string;
+    readonly index: string;
+    readonly backslashEscapes?: boolean;
+}): readonly IndexKeyOperand[] | undefined;
+/** Render a real expression-index normalization host, never a scalar CHECK surrogate. */
+export declare function renderIndexExpressionProbe({ ...params }: IndexExpressionProbeParams): readonly RenderedQuery[];
+/** Version admission after a connection reveals its host, before scratch or user index DDL. */
+export declare function assertIndexExpressionVersion({ dialect, version }: {
+    readonly dialect: Dialect;
+    readonly version: string;
+}): void;
+//# sourceMappingURL=index-expressions.d.ts.map

package/dist/index.d.ts

@@ -8,9 +8,11 @@ export { renderExternalDependents } from "./dialects/external-dependents.ts";
 export type { ExternalDependentTarget } from "./dialects/external-dependents.ts";
 export { renderPostgresPhysicalCatalog } from "./dialects/postgres-physical-catalog.ts";
 export type { PostgresPhysicalCatalogQuery } from "./dialects/postgres-physical-catalog.ts";
-export { renderPostgresIndexKeys } from "./dialects/postgres-index-keys.ts";
+export { renderPostgresIndexKeys, renderPostgresJitSuspend, renderPostgresJitRestore } from "./dialects/postgres-index-keys.ts";
 export { renderIndexColumns } from "./index-columns.ts";
 export type { IndexColumnOperand } from "./index-columns.ts";
+export { resolveIndexKeys, renderIndexKeys, extractIndexKeys, renderIndexExpressionProbe, assertIndexExpressionVersion } from "./index-expressions.ts";
+export type { IndexKeyOperand, IndexExpressionProbeParams } from "./index-expressions.ts";
 export { renderModuleDependencyQuery } from "./dialects/module-dependency.ts";
 export type { ModuleDependencyOperation } from "./dialects/module-dependency.ts";
 export { renderReplayCoverageGaps } from "./dialects/migration-replay-coverage.ts";
@@ -38,9 +40,9 @@ export type { ResultDecoder, ResultReadDecoder, ResultParameterEncoder, ResultSc
  * lives in this package; see the root sql-catalog.md for the reviewable surface.
  */
 export { compileExclusion, renderExclusionSetup, renderExclusionDdl, renderExclusionCatalog, renderExclusionProbe } from "./exclusion.ts";
-export type { AdvisoryLockKey, AdvisoryLockStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainStatement, ChainStep, ChainStepStatement, ChainTally, ChainVeto, ColRef, ComparisonOp, CountSubquery, DeleteStatement, ExcludedRef, InnerJoin, KeyTableJoin, KeyTableMember, InsertSelectStatement, InsertStatement, ReturningColumn, JsonFilterOp, LateralJoin, ListSetOperation, OnConflictClause, OnConflictDoNothing, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, DbNowMarker, JsonParamCell, SelectExpr, SelectStatement, SetOperation, SetOperator, SqlExpr, SqlStatement, StepColumnRef, TableRef, UpdateStatement, } from "./ast.ts";
+export type { AdvisoryLockKey, AdvisoryLockStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainStatement, ChainStep, ChainStepStatement, ChainTally, ChainVeto, ColRef, ComparisonOp, CountSubquery, DeleteStatement, ExcludedRef, InnerJoin, KeyListMember, KeyPage, KeyTableJoin, KeyTableMember, InsertSelectStatement, InsertStatement, ReturningColumn, JsonFilterOp, LateralJoin, LeftJoin, ListSetOperation, OnConflictClause, OnConflictDoNothing, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, DbNowMarker, JsonParamCell, SelectExpr, SelectStatement, SetOperation, SetOperator, SqlExpr, SqlStatement, StepColumnRef, TableRef, UpdateStatement, } from "./ast.ts";
 export { ADVISORY_LOCK_RESULT_COLUMN, CHAIN_VETO_PREFIX, CHAIN_VETO_TOKEN_PATTERN, SQL_DEFAULT_CELL, chainVetoToken, dbNowMarker, excludedRef, isDbNowMarker, isExcludedRef, isJsonParamCell, isListSetOperation, isSetOperation, isSqlDefaultCell, isStepColumnRef, jsonParamCell, returningColumnName, stepColumnRef, } from "./ast.ts";
-export type { AdvisoryLockFunctions, AdvisoryLockModeFunctions, RowLockSyntax, SqlDialect, } from "./dialect.ts";
+export type { AdvisoryLockFunctions, AdvisoryLockModeFunctions, RowLockSyntax, EmptyInsertSyntax, SqlDialect, } from "./dialect.ts";
 export { ADVISORY_KEY_BOUNDS, describeRowLock, renderAdvisoryLock, renderRowLockClause } from "./locks.ts";
 export { JSON_TRANSPORT, projectionOutputName } from "./json-transport.ts";
 export { postgresDialect } from "./dialects/postgres.ts";
@@ -48,10 +50,21 @@ export { sqliteDialect } from "./dialects/sqlite.ts";
 export { mysqlDialect } from "./dialects/mysql.ts";
 export { SQL_DIALECTS, getSqlDialect } from "./dialects/registry.ts";
 export { tableDefinitionParts } from "./dialects/sqlite-table-definition.ts";
-export { renderPredicate } from "./predicate.ts";
+export { keyListBindsUntypedRows, postgresBulkInsertArrayCastOf, postgresKeyListElementTypeOf } from "./key-list.ts";
+export { renderPredicate, renderSchemaExpression } from "./predicate.ts";
+export { renderLocalDateCheck } from "./local-date.ts";
+export { renderGeneratedColumnClause } from "./generated-columns.ts";
+export type { GeneratedColumnDeclaration, ExtractedGeneratedColumn } from "./generated-columns.ts";
+export { renderPostgresGeneratedColumnProbe, renderPostgresDropGeneratedExpression } from "./dialects/postgres-generated-columns.ts";
+export type { PostgresGeneratedColumnProbe } from "./dialects/postgres-generated-columns.ts";
+export { renderMysqlGeneratedColumnProbe, extractMysqlGeneratedColumn } from "./dialects/mysql-generated-columns.ts";
+export type { MysqlGeneratedColumnProbe } from "./dialects/mysql-generated-columns.ts";
+export { extractSqliteGeneratedColumn } from "./dialects/sqlite-generated-columns.ts";
+export { renderRowRule } from "./row-rules.ts";
+export type { RenderedRowRule, RowRuleStatement, RowRuleTriggerPlacement } from "./row-rules.ts";
 export type { PredicateModel, PredicateUsage } from "./predicate.ts";
 export { DIALECT_CAPABILITIES, MYSQL_CAPABILITIES, POSTGRES_CAPABILITIES, SQLITE_CAPABILITIES, } from "./capabilities.ts";
-export { DIALECT_CODECS, MYSQL_CODECS, POSTGRES_CODECS, SQLITE_CODECS, decodeIsNoop, enumMembershipCodec, float32Codec, parseDateTimeText, parseJsonText, postgresArrayElementFromText, shortestFloat32, timeOfDayCodec, } from "./codecs.ts";
+export { DIALECT_CODECS, MYSQL_CODECS, POSTGRES_CODECS, SQLITE_CODECS, decodeIsNoop, enumMembershipCodec, float32Codec, localDateCodec, parseDateTimeText, parseJsonText, postgresArrayElementFromText, shortestFloat32, timeOfDayCodec, } from "./codecs.ts";
 export type { CodecTable, ScalarCodec, WireFidelity } from "./codecs.ts";
 export { renderExpr, renderFragment, renderProjection, renderStatement } from "./render.ts";
 export type { RenderedQuery } from "./render.ts";
@@ -59,7 +72,7 @@ export { snapshotSqlValue } from "./parameter-snapshot.ts";
 export { ParamCollector } from "./params.ts";
 export { NATIVE_RLS, renderRlsColumnType, renderRlsContext, renderRlsDisable, renderRlsDropPolicy, renderRlsEnable, renderRlsForce, renderRlsNoForce, renderRlsPolicy, renderRlsPredicate, renderRlsRole } from "./dialects/postgres-rls.ts";
 export type { RlsContextStatement, RlsDisableStatement, RlsDropPolicyStatement, RlsEnableStatement, RlsForceStatement, RlsNoForceStatement, RlsPolicyStatement, RlsRoleStatement } from "./ast.ts";
-export { containsPattern, endsWithPattern, escapeGlobPattern, escapeLikePattern, startsWithPattern, strictMatchPattern } from "./like.ts";
+export { containsPattern, endsWithPattern, escapeGlobPattern, escapeLikePattern, startsWithPattern, strictMatchCollationPrefilter, strictMatchPattern } from "./like.ts";
 export { RLS_READINESS_SQL, NATIVE_RLS_PROBE_POLICY, renderRlsReadinessQuery, renderRlsProbeTable, renderRlsPolicyPath } from "./dialects/postgres-rls-readiness.ts";
 export type { RlsReadinessQuery } from "./dialects/postgres-rls-readiness.ts";
 export { isFixedDiagnostic, renderDiagnostic } from "./dialects/diagnostics.ts";