bazis 0.114.0 → 0.115.0

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.114.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.115.0" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/orm/ownedStoreContributions.ts

@@ -57,6 +57,10 @@ function snapshot<TContext extends DbContext>(context: ContextClass<TContext>, e
   const definition = isDefinedOrmOwnedStoreV1(source) ? source : defineOrmOwnedStoreV1(source as OrmOwnedStoreDefinitionV1);
   const expected = compileExpectedSchema(new OrmModel(entities));
   if (expected.tables.length === 0 || expected.tables.length > 512) fail("ORM_OWNED_STORE_IDENTITY_MISMATCH", `${storeName(definition)} needs 1 to 512 entities, got ${expected.tables.length}`);
+  for (const table of expected.tables) {
+    const partial = table.indexes.find((index) => index.predicate !== undefined);
+    if (partial) fail("ORM_OWNED_STORE_IDENTITY_MISMATCH", `${storeName(definition)}: index "${partial.name}" on "${table.table}" has a where condition; owned stores do not support partial indexes`);
+  }
   return Object.freeze({ identity: Object.freeze({}), context, entities: Object.freeze([...entities]), definition, expected, source });
 }
 

package/library/orm/Metadata/ModelBuilder.ts

@@ -1,7 +1,7 @@
 import { ModelBuildError } from "../errors";
 import { readRawEntity, type RawProperty } from "./decorators";
 import { defaultTableName, isConventionalKey, resolveColumnType } from "./conventions";
-import { validateCheckAst } from "../Schema/CheckExpression";
+import { validateCheckAst, type CheckAst } from "../Schema/CheckExpression";
 import type {
   EntityModel,
   ForeignKeyModel,
@@ -57,6 +57,7 @@ export class ModelBuilder {
           name: rawProp.index.name ?? `ix_${(raw.table ?? defaultTableName(ctor.name)).toLowerCase()}_${property.columnName}`,
           columns: [property.columnName],
           unique: rawProp.index.unique,
+          ...(rawProp.index.where === undefined ? {} : { where: rawProp.index.where }),
         });
       }
       if (rawProp.fkTarget) {
@@ -177,12 +178,13 @@ export class ModelBuilder {
         return property.columnName;
       });
       if (new Set(columns).size !== columns.length) throw new ModelBuildError(`Entity "${ctor.name}": index contains duplicate properties.`);
-      indexes.push({ name: declared.name ?? `ix_${(raw.table ?? defaultTableName(ctor.name)).toLowerCase()}_${columns.join("_")}`, columns, unique: declared.unique });
+      indexes.push({ name: declared.name ?? `ix_${(raw.table ?? defaultTableName(ctor.name)).toLowerCase()}_${columns.join("_")}`, columns, unique: declared.unique, ...(declared.where === undefined ? {} : { where: declared.where }) });
     }
     const indexNames = new Set<string>();
     for (const index of indexes) {
       if (indexNames.has(index.name)) throw new ModelBuildError(`Entity "${ctor.name}": duplicate index name "${index.name}".`);
       indexNames.add(index.name);
+      if (index.where !== undefined) validateIndexCondition(ctor.name, index.name, index.where, properties);
     }
     // Encryption with a random nonce stores equal values differently: such a
     // column cannot identify a row or be unique.
@@ -346,3 +348,24 @@ function isCanonicalRfc3339(value: string): boolean {
   }
   return true;
 }
+
+/**
+ * A partial index condition uses the `@Check` operators. A date literal is
+ * refused: PostgreSQL stores it in its own time zone form, so the declared
+ * and the stored conditions could never be compared.
+ */
+function validateIndexCondition(entity: string, index: string, where: CheckAst, properties: readonly PropertyModel[]): void {
+  validateCheckAst(where, properties, `Entity "${entity}": index "${index}" condition`);
+  const byName = new Map(properties.map((property) => [property.propertyName, property]));
+  const visit = (node: CheckAst): void => {
+    switch (node.kind) {
+      case "and":
+      case "or": visit(node.left); visit(node.right); return;
+      case "not": visit(node.inner); return;
+      case "null": return;
+    }
+    if (byName.get(node.left)?.type !== "datetime") return;
+    if (node.kind === "in" || !(typeof node.right === "string" && node.right.startsWith("\0"))) throw new ModelBuildError(`Entity "${entity}": index "${index}" condition compares "${node.left}" with a date literal; use isNull()/isNotNull() or compare with another column.`);
+  };
+  visit(where);
+}

package/library/orm/Metadata/decorators.ts

@@ -62,10 +62,18 @@ export interface UUIDOptions {
   readonly name?: string;
 }
 
-/** `@Index` options (on a property). */
-export interface IndexOptions {
+/** `@Index` options. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface IndexOptions<T extends object = any> {
   readonly unique?: boolean;
   readonly name?: string;
+  /**
+   * Partial index: only rows that match the condition are indexed. With
+   * `@SoftDelete` a unique index keeps deleted rows out:
+   * `@Index<User>(["email"], { unique: true, where: (u) => u.deletedAt.isNull() })`.
+   * The condition uses the same operators as `@Check`.
+   */
+  readonly where?: CheckPredicate<T>;
 }
 export interface CompositeKeyOptions { readonly name?: string }
 export type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull";
@@ -87,7 +95,7 @@ export interface RawProperty {
   required?: boolean;
   nullable?: boolean;
   default?: ColumnDefaultValue;
-  index?: { unique: boolean; name?: string };
+  index?: { unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst };
   /** `@ForeignKey(() => Principal)` on a scalar column, for the DDL FK. */
   fkTarget?: () => EntityClass;
   /** `@HasConversion(...)`: conversion before/after the dialect. */
@@ -119,7 +127,7 @@ export interface RawEntity {
   /** Soft-delete property name (see `@SoftDelete` / `@Entity({ softDelete })`). */
   softDeleteProperty?: string;
   keyDeclaration?: { properties: readonly string[]; name?: string; anchor: string; composite: boolean };
-  indexes?: Array<{ properties: readonly string[]; unique: boolean; name?: string }>;
+  indexes?: Array<{ properties: readonly string[]; unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst }>;
   foreignKeys?: Array<{ properties: readonly string[]; target: () => EntityClass; name?: string; onDelete?: ReferentialAction; onUpdate?: ReferentialAction }>;
   checks?: Array<{ name: string; expression: import("../Schema/CheckExpression").CheckAst }>;
 }
@@ -292,17 +300,21 @@ export function Required() {
 }
 
 /** Index on the property's column. */
-export function Index(options?: IndexOptions): (value: undefined, context: ClassFieldDecoratorContext) => void;
-export function Index(properties: readonly [string, ...string[]], options?: IndexOptions): (value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext) => void;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Index<T extends object = any>(options?: IndexOptions<T>): (value: undefined, context: ClassFieldDecoratorContext) => void;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Index<T extends object = any>(properties: readonly [string, ...string[]], options?: IndexOptions<T>): (value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext) => void;
 export function Index(first: IndexOptions | readonly [string, ...string[]] = {}, options: IndexOptions = {}) {
   if (Array.isArray(first)) {
+    const where = options.where === undefined ? undefined : compileCheck(options.where);
     return (_value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
-      (ownRaw(context.metadata).indexes ??= []).push({ properties: [...first], unique: options.unique === true, name: options.name });
+      (ownRaw(context.metadata).indexes ??= []).push({ properties: [...first], unique: options.unique === true, name: options.name, ...(where === undefined ? {} : { where }) });
     };
   }
   const propertyOptions = first as IndexOptions;
+  const where = propertyOptions.where === undefined ? undefined : compileCheck(propertyOptions.where);
   return (_value: undefined, context: ClassFieldDecoratorContext): void => {
-    ownProperty(context.metadata, fieldName(context)).index = { unique: propertyOptions.unique === true, name: propertyOptions.name };
+    ownProperty(context.metadata, fieldName(context)).index = { unique: propertyOptions.unique === true, name: propertyOptions.name, ...(where === undefined ? {} : { where }) };
   };
 }
 

package/library/orm/Metadata/types.ts

@@ -72,6 +72,8 @@ export interface IndexModel {
   readonly name: string;
   readonly columns: readonly string[];
   readonly unique: boolean;
+  /** Partial index condition over property names (`@Index({ where })`). */
+  readonly where?: CheckAst;
 }
 export interface CheckModel { readonly name: string; readonly expression: CheckAst }
 

package/library/orm/Providers/PostgresDialect.ts

@@ -165,9 +165,10 @@ export class PostgresDialect implements SqlDialect {
   createIndexSqlOne(model: EntityModel, index: IndexModel): string {
     const unique = index.unique ? "UNIQUE " : "";
     const cols = index.columns.map((column) => this.quoteId(column)).join(", ");
+    const where = index.where === undefined ? "" : ` WHERE ${renderCheck(projectCheckAstIdentifiers(index.where, (name) => model.propertyByName(name)!.columnName), (name) => this.quoteId(name))}`;
     return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteId(index.name)} ON ${this.qualifyTable(
       model,
-    )} (${cols})`;
+    )} (${cols})${where}`;
   }
 
   addColumnSql(model: EntityModel, property: PropertyModel, foreignKey?: ForeignKeyConstraint): string {

package/library/orm/Providers/PostgresProvider.ts

@@ -476,7 +476,7 @@ export class PostgresProvider implements DatabaseProvider {
       const column = String(row.column_name);
       return [column, { name: column, notNull: row.not_null === true, isPrimaryKey: primaryColumns.has(column), ...normalized, physicalType: exact ? exactPostgresType(String(row.type_name), normalized.physicalType) : normalized.physicalType }];
     }));
-    const indexRows = await executor.query(`SELECT ic.relname AS index_name, ix.indisunique AS is_unique, am.amname AS method, ix.indpred IS NOT NULL AS has_predicate, ix.indisvalid AS is_valid, ix.indisready AS is_ready, ix.indnkeyatts AS key_count, k.ord, a.attname AS column_name, k.attnum = 0 AS is_expression, k.ord > ix.indnkeyatts AS is_include,
+    const indexRows = await executor.query(`SELECT ic.relname AS index_name, ix.indisunique AS is_unique, am.amname AS method, ix.indpred IS NOT NULL AS has_predicate, pg_get_expr(ix.indpred, ix.indrelid, true) AS predicate, ix.indisvalid AS is_valid, ix.indisready AS is_ready, ix.indnkeyatts AS key_count, k.ord, a.attname AS column_name, k.attnum = 0 AS is_expression, k.ord > ix.indnkeyatts AS is_include,
       EXISTS (SELECT 1 FROM pg_constraint c WHERE c.conindid = ix.indexrelid AND c.contype IN ('p', 'u')) AS backing_constraint
       FROM pg_index ix JOIN pg_class ic ON ic.oid = ix.indexrelid JOIN pg_class tc ON tc.oid = ix.indrelid JOIN pg_namespace n ON n.oid = tc.relnamespace JOIN pg_am am ON am.oid = ic.relam JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY k(attnum, ord) ON true LEFT JOIN pg_attribute a ON a.attrelid = tc.oid AND a.attnum = k.attnum
       WHERE n.nspname = $1 AND tc.relname = $2 ORDER BY ic.relname, k.ord`, [schema, name]);

package/library/orm/Providers/PostgresSchema.decoder.ts

@@ -1,6 +1,6 @@
 import type { Row } from "./types";
 import type { IntrospectedColumn, IntrospectedIndex, IntrospectedForeignKey } from "../Schema/introspection";
-import { parseRenderedCheck } from "../Schema/CheckExpression";
+import { parsePostgresPredicate, type CheckAst } from "../Schema/CheckExpression";
 
 export function canonicalPostgresColumn(type: string, defaultExpression: string | null, identity: string): Pick<IntrospectedColumn, "physicalType" | "default" | "generation" | "unsupported"> {
   const physicalType = canonicalPostgresType(type);
@@ -78,10 +78,10 @@ function stripPostgresCasts(value: string): string { return value.replace(/::(?:
 function stripPostgresOuter(value: string): string { while (value.startsWith("(") && value.endsWith(")")) value = value.slice(1, -1).trim(); return value; }
 
 export function collectPostgresIndexes(rows: readonly Row[], exact = false): IntrospectedIndex[] {
-  const byName = new Map<string, { unique: boolean; columns: string[]; method: "btree" | undefined; backingConstraint: boolean; unsupported: boolean; predicate?: string }>();
+  const byName = new Map<string, { unique: boolean; columns: string[]; method: "btree" | undefined; backingConstraint: boolean; unsupported: boolean; predicate?: CheckAst }>();
   for (const row of rows) {
     const name = String(row.index_name); let index = byName.get(name);
-    if (!index) { index = { unique: row.is_unique === true, columns: [], method: String(row.method) === "btree" ? "btree" : undefined, backingConstraint: row.backing_constraint === true, unsupported: row.is_expression === true || row.is_valid !== true || row.is_ready !== true }; if (row.has_predicate === true) index.predicate = "unsupported"; byName.set(name, index); }
+    if (!index) { index = { unique: row.is_unique === true, columns: [], method: String(row.method) === "btree" ? "btree" : undefined, backingConstraint: row.backing_constraint === true, unsupported: row.is_expression === true || row.is_valid !== true || row.is_ready !== true }; if (row.has_predicate === true) { const predicate = typeof row.predicate === "string" ? parsePostgresPredicate(row.predicate) : undefined; if (predicate === undefined) index.unsupported = true; else index.predicate = predicate; } byName.set(name, index); }
     if (row.column_name == null || (exact && row.is_include === true)) index.unsupported = true; else index.columns.push(String(row.column_name));
   }
   return [...byName.entries()].map(([name, value]) => ({ name, unique: value.unique, columns: value.columns, method: value.method, backingConstraint: value.backingConstraint, predicate: value.predicate, unsupported: value.unsupported }));
@@ -100,8 +100,8 @@ export function collectPostgresForeignKeys(rows: readonly Row[], exact = false):
 function postgresAction(code: string): { readonly value: string; readonly unsupported: boolean } { switch (code) { case "a": return { value: "noAction", unsupported: false }; case "r": return { value: "restrict", unsupported: false }; case "c": return { value: "cascade", unsupported: false }; case "n": return { value: "setNull", unsupported: false }; default: return { value: "unknown", unsupported: true }; } }
 
 export function canonicalPostgresCheck(name: string, definition: string): { readonly name: string; readonly expression: unknown; readonly unsupported: boolean } {
-  const body = definition.trim().match(/^CHECK\s*\((.*)\)$/isu)?.[1]?.replace(/::(?:[A-Za-z_][A-Za-z0-9_]*(?:\[\])?)/gu, "");
-  const expression = body === undefined ? undefined : parseRenderedCheck(body);
+  const body = definition.trim().match(/^CHECK\s*\((.*)\)$/isu)?.[1];
+  const expression = body === undefined ? undefined : parsePostgresPredicate(body);
   return { name, expression: expression ?? { kind: "unsupported" }, unsupported: expression === undefined };
 }
 

package/library/orm/Schema/CheckExpression.ts

@@ -125,17 +125,17 @@ export function projectCheckAstIdentifiers(ast: CheckAst, resolve: (propertyName
   }
 }
 /** Validates the complete closed AST against the compiled entity columns before DDL/snapshot rendering. */
-export function validateCheckAst(ast: CheckAst, properties: readonly PropertyModel[]): void {
+export function validateCheckAst(ast: CheckAst, properties: readonly PropertyModel[], subject = "CHECK"): void {
   const byName = new Map(properties.map((property) => [property.propertyName, property]));
   const property = (name: string): PropertyModel => {
     const value = byName.get(name);
     if (!value)
-      throw new ModelBuildError(`CHECK references unknown property "${name}".`);
+      throw new ModelBuildError(`${subject} references unknown property "${name}".`);
     return value;
   };
   const validateLiteral = (column: PropertyModel, value: CheckScalar): void => {
     if (value === null)
-      throw new ModelBuildError(`CHECK comparison for "${column.propertyName}" must use isNull()/isNotNull().`);
+      throw new ModelBuildError(`${subject} comparison for "${column.propertyName}" must use isNull()/isNotNull().`);
     const compatible = (column.type === "integer" || column.type === "real")
       ? typeof value === "number"
       : (column.type === "text" || column.type === "datetime")
@@ -144,7 +144,7 @@ export function validateCheckAst(ast: CheckAst, properties: readonly PropertyMod
           ? typeof value === "boolean"
           : false;
     if (!compatible)
-      throw new ModelBuildError(`CHECK literal is incompatible with property "${column.propertyName}".`);
+      throw new ModelBuildError(`${subject} literal is incompatible with property "${column.propertyName}".`);
   };
   const visit = (node: CheckAst): void => {
     switch (node.kind) {
@@ -162,7 +162,7 @@ export function validateCheckAst(ast: CheckAst, properties: readonly PropertyMod
       case "in": {
         const left = property(node.left);
         if (!node.values.length || node.values.length > MAX_CHECK_IN_VALUES)
-          throw new ModelBuildError(`CHECK IN requires between 1 and ${MAX_CHECK_IN_VALUES} literals.`);
+          throw new ModelBuildError(`${subject} IN requires between 1 and ${MAX_CHECK_IN_VALUES} literals.`);
         for (const value of node.values)
           validateLiteral(left, value);
         return;
@@ -173,13 +173,13 @@ export function validateCheckAst(ast: CheckAst, properties: readonly PropertyMod
         if (rightName !== undefined) {
           const right = property(rightName);
           if (left.type !== right.type)
-            throw new ModelBuildError(`CHECK column comparison requires identical column types ("${left.propertyName}", "${right.propertyName}").`);
+            throw new ModelBuildError(`${subject} column comparison requires identical column types ("${left.propertyName}", "${right.propertyName}").`);
         }
         else {
           validateLiteral(left, node.right as CheckScalar);
         }
         if ([">", ">=", "<", "<="].includes(node.op) && !["integer", "real", "text", "datetime"].includes(left.type)) {
-          throw new ModelBuildError(`CHECK ordered comparison is not supported for property "${left.propertyName}".`);
+          throw new ModelBuildError(`${subject} ordered comparison is not supported for property "${left.propertyName}".`);
         }
       }
     }
@@ -215,6 +215,13 @@ export function parseRenderedCheck(value: string): CheckAst | undefined {
     const left = parseIdentifier(nullable[1]!);
     return left ? { kind: "null", left, not: Boolean(nullable[2]) } : undefined;
   }
+  // PostgreSQL stores IN (...) as = ANY (ARRAY[...]).
+  const anyMatch = source.match(/^(.+?)\s*=\s*ANY\s*\(\s*ARRAY\[(.*)\]\s*\)$/isu);
+  if (anyMatch) {
+    const left = parseIdentifier(anyMatch[1]!);
+    const values = splitLiterals(anyMatch[2]!);
+    return left && values ? { kind: "in", left, values } : undefined;
+  }
   const inMatch = source.match(/^(.+?)\s+IN\s*\((.*)\)$/isu);
   if (inMatch) {
     const left = parseIdentifier(inMatch[1]!);
@@ -228,6 +235,46 @@ export function parseRenderedCheck(value: string): CheckAst | undefined {
   const right = parseOperand(comparison[3]!);
   return left && right !== undefined ? { kind: "compare", left, op: comparison[2]! as "=" | "<>" | ">" | ">=" | "<" | "<=", right } : undefined;
 }
+/**
+ * Reads an expression PostgreSQL deparsed (`pg_get_expr`, a partial index
+ * predicate): casts like `'x'::text` are dropped outside string literals.
+ * Unknown syntax returns undefined.
+ */
+export function parsePostgresPredicate(value: string): CheckAst | undefined {
+  let result = "";
+  let quoted = false;
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i]!;
+    if (char === "'") quoted = !quoted;
+    if (!quoted && char === ":" && value[i + 1] === ":") {
+      const cast = value.slice(i).match(/^::(?:timestamp with(?:out)? time zone|time with(?:out)? time zone|double precision|character varying|[A-Za-z_][A-Za-z0-9_]*)(?:\[\])?/u);
+      if (cast) { i += cast[0].length - 1; continue; }
+    }
+    result += char;
+  }
+  return parseRenderedCheck(result);
+}
+/**
+ * One form for equal conditions: `(a AND b) AND c` and `a AND (b AND c)` are
+ * the same chain, as PostgreSQL prints it. Used to compare a declared
+ * condition with the one read from the catalog.
+ */
+export function normalizeCheckAst(ast: CheckAst): CheckAst {
+  switch (ast.kind) {
+    case "and":
+    case "or": {
+      const items: CheckAst[] = [];
+      const collect = (node: CheckAst): void => {
+        if (node.kind === ast.kind) { collect(node.left); collect(node.right); }
+        else items.push(normalizeCheckAst(node));
+      };
+      collect(ast);
+      return items.reduce((left, right) => ({ kind: ast.kind, left, right }));
+    }
+    case "not": return { kind: "not", inner: normalizeCheckAst(ast.inner) };
+    default: return ast;
+  }
+}
 function stripOuter(value: string): string {
   while (value.startsWith("(") && value.endsWith(")") && balancedOuter(value))
     value = value.slice(1, -1).trim();

package/library/orm/Schema/ExactSchemaVerifier.ts

@@ -1,7 +1,8 @@
 import type { OrmExpectedSchema } from "./ExpectedSchema";
 import type { IntrospectedSchema, IntrospectedTable } from "./introspection";
 import { createHash } from "node:crypto";
-export type SchemaDifferenceCode = "table.missing" | "column.missing" | "column.unexpected" | "column.type" | "column.nullability" | "column.default" | "column.generation" | "primaryKey.missing" | "primaryKey.unexpected" | "primaryKey.name" | "primaryKey.columns" | "index.missing" | "index.unexpected" | "index.name" | "index.columns" | "index.uniqueness" | "index.method" | "index.unsupportedShape" | "foreignKey.missing" | "foreignKey.unexpected" | "foreignKey.name" | "foreignKey.columns" | "foreignKey.target" | "foreignKey.actions" | "foreignKey.deferrable" | "foreignKey.match" | "check.missing" | "check.unexpected" | "check.name" | "check.expression" | "catalog.unsupported";
+import { normalizeCheckAst, type CheckAst } from "./CheckExpression";
+export type SchemaDifferenceCode = "table.missing" | "column.missing" | "column.unexpected" | "column.type" | "column.nullability" | "column.default" | "column.generation" | "primaryKey.missing" | "primaryKey.unexpected" | "primaryKey.name" | "primaryKey.columns" | "index.missing" | "index.unexpected" | "index.name" | "index.columns" | "index.uniqueness" | "index.method" | "index.predicate" | "index.unsupportedShape" | "foreignKey.missing" | "foreignKey.unexpected" | "foreignKey.name" | "foreignKey.columns" | "foreignKey.target" | "foreignKey.actions" | "foreignKey.deferrable" | "foreignKey.match" | "check.missing" | "check.unexpected" | "check.name" | "check.expression" | "catalog.unsupported";
 export interface SafeSchemaDescriptor {
   readonly kind: "absent" | "present" | "canonicalType" | "canonicalDefault" | "canonicalGeneration" | "canonicalExpression" | "orderedColumns" | "referentialActions" | "unsupported";
   readonly value?: string;
@@ -85,7 +86,7 @@ export class ExactSchemaVerifier {
     const ordinary = actual.indexes.filter((index) => !index.backingConstraint);
     const expectedIndexes = new Map(expected.indexes.map((index) => [index.name, index]));
     for (const index of ordinary) {
-      if (index.unsupported || index.method !== "btree" || index.predicate || index.columns.length === 0)
+      if (index.unsupported || index.method !== "btree" || index.columns.length === 0)
         add("index.unsupportedShape", table, index.name, undefined, unsupported);
       else if (!expectedIndexes.has(index.name))
         add("index.unexpected", table, index.name, absent, present);
@@ -98,7 +99,7 @@ export class ExactSchemaVerifier {
       }
       if (found.name !== name)
         add("index.name", table, name, value("present", name), value("present", found.name));
-      if (found.unsupported || found.predicate || found.columns.length === 0) {
+      if (found.unsupported || found.columns.length === 0) {
         add("catalog.unsupported", table, name, undefined, unsupported);
         continue;
       }
@@ -108,6 +109,8 @@ export class ExactSchemaVerifier {
         add("index.columns", table, name, value("orderedColumns", index.columns), value("orderedColumns", found.columns));
       if (found.method !== "btree")
         add("index.method", table, name, value("present", "btree"), value("present", found.method ?? "unknown"));
+      if (!samePredicate(found.predicate, index.predicate))
+        add("index.predicate", table, name, value("canonicalExpression", index.predicate ?? null), value("canonicalExpression", found.predicate ?? null));
     }
     const foreignKeys = actual.foreignKeys ?? [];
     const expectedForeignKeys = new Map(expected.foreignKeys.map((foreignKey) => [foreignKey.name, foreignKey]));
@@ -148,12 +151,22 @@ export class ExactSchemaVerifier {
       else {
         if (found.name !== name)
           add("check.name", table, name, value("present", name), value("present", found.name));
-        if (stable(found.expression) !== stable(check.expression))
+        if (!sameExpression(found.expression, check.expression))
           add("check.expression", table, name, value("canonicalExpression", check.expression), value("canonicalExpression", found.expression));
       }
     }
   }
 }
+/** A CHECK read from the catalog against the declared one; AND/OR chains compare flat. */
+function sameExpression(found: unknown, declared: unknown): boolean {
+  const known = (value: unknown): value is CheckAst => typeof value === "object" && value !== null && (value as { kind?: unknown }).kind !== "unsupported";
+  return known(found) && known(declared) ? stable(normalizeCheckAst(found)) === stable(normalizeCheckAst(declared)) : stable(found) === stable(declared);
+}
+/** @internal Two partial index conditions (or their absence) are the same. */
+export function samePredicate(a: CheckAst | undefined, b: CheckAst | undefined): boolean {
+  if (a === undefined || b === undefined) return a === b;
+  return stable(normalizeCheckAst(a)) === stable(normalizeCheckAst(b));
+}
 function same<T>(a: readonly T[], b: readonly T[]): boolean {
   return a.length === b.length && a.every((entry, index) => stable(entry) === stable(b[index]));
 }

package/library/orm/Schema/ExpectedSchema.ts

@@ -1,13 +1,13 @@
 import type { EntityModel } from "../Metadata/types";
 import type { OrmModel } from "../Metadata/OrmModel";
 import type { CanonicalDefault, GenerationStrategy } from "./introspection";
-import { projectCheckAstIdentifiers } from "./CheckExpression";
+import { projectCheckAstIdentifiers, type CheckAst } from "./CheckExpression";
 import { crossUnitForeignKey, physicalColumnTypes } from "./physicalColumnTypes";
 import { SchemaAdmissionError } from "../errors";
 import { physicalTableIdentity } from "./tableKey";
 
 export interface ExpectedColumn { readonly property: string; readonly column: string; readonly physicalType: string; readonly nullable: boolean; readonly default: CanonicalDefault; readonly generation: GenerationStrategy }
-export interface ExpectedTable { readonly schema: string; readonly table: string; readonly columns: readonly ExpectedColumn[]; readonly primaryKey: { readonly name: string; readonly columns: readonly string[] }; readonly indexes: readonly { readonly name: string; readonly columns: readonly string[]; readonly unique: boolean; readonly method: "btree" }[]; readonly foreignKeys: readonly { readonly name: string; readonly columns: readonly string[]; readonly target: { readonly schema: string; readonly table: string }; readonly targetColumns: readonly string[]; readonly onDelete: string; readonly onUpdate: string }[]; readonly checks: readonly { readonly name: string; readonly expression: unknown }[] }
+export interface ExpectedTable { readonly schema: string; readonly table: string; readonly columns: readonly ExpectedColumn[]; readonly primaryKey: { readonly name: string; readonly columns: readonly string[] }; readonly indexes: readonly { readonly name: string; readonly columns: readonly string[]; readonly unique: boolean; readonly method: "btree"; readonly predicate?: CheckAst }[]; readonly foreignKeys: readonly { readonly name: string; readonly columns: readonly string[]; readonly target: { readonly schema: string; readonly table: string }; readonly targetColumns: readonly string[]; readonly onDelete: string; readonly onUpdate: string }[]; readonly checks: readonly { readonly name: string; readonly expression: unknown }[] }
 export interface OrmExpectedSchema { readonly tables: readonly ExpectedTable[] }
 
 const schemaOf = (model: EntityModel) => physicalTableIdentity(model).schema?.trim() || "public";
@@ -41,5 +41,5 @@ function compileTable(model: EntityModel, byCtor: ReadonlyMap<EntityModel["ctor"
     if (!target) throw crossUnitForeignKey(model, foreignKey.properties, foreignKey.target());
     return { name: foreignKey.name ?? `fk_${table}_${foreignKey.properties.join("_")}`, columns: foreignKey.properties.map((name) => model.propertyByName(name)!.columnName), target: { schema: schemaOf(target), table: physicalTableIdentity(target).table }, targetColumns: target.key.map((property) => property.columnName), onDelete: foreignKey.onDelete, onUpdate: foreignKey.onUpdate };
   });
-  return Object.freeze({ schema, table, columns: Object.freeze(columns), primaryKey: Object.freeze({ name: model.keyName ?? `pk_${table}`, columns: Object.freeze(model.key.map((property) => property.columnName)) }), indexes: Object.freeze(model.indexes.map((index) => Object.freeze({ ...index, columns: Object.freeze([...index.columns]), method: "btree" as const }))), foreignKeys: Object.freeze(foreignKeys), checks: Object.freeze(model.checks.map((check) => Object.freeze({ name: check.name, expression: projectCheckAstIdentifiers(check.expression, (name) => model.propertyByName(name)!.columnName) }))) });
+  return Object.freeze({ schema, table, columns: Object.freeze(columns), primaryKey: Object.freeze({ name: model.keyName ?? `pk_${table}`, columns: Object.freeze(model.key.map((property) => property.columnName)) }), indexes: Object.freeze(model.indexes.map((index) => Object.freeze({ name: index.name, columns: Object.freeze([...index.columns]), unique: index.unique, method: "btree" as const, ...(index.where === undefined ? {} : { predicate: projectCheckAstIdentifiers(index.where, (name) => model.propertyByName(name)!.columnName) }) }))), foreignKeys: Object.freeze(foreignKeys), checks: Object.freeze(model.checks.map((check) => Object.freeze({ name: check.name, expression: projectCheckAstIdentifiers(check.expression, (name) => model.propertyByName(name)!.columnName) }))) });
 }

package/library/orm/Schema/SafeAdditiveSchema.ts

@@ -70,7 +70,7 @@ export function renderSafeAdditivePostgres(operation: SafeAdditiveSchemaOperatio
     case "addColumn": return `ALTER TABLE ${tableName(operation.table)} ADD COLUMN ${column(operation.column)}`;
     case "addCheck": return `ALTER TABLE ${tableName(operation.table)} ADD CONSTRAINT ${q(operation.check.name)} CHECK (${renderCheck(operation.check.expression as never, q)})`;
     case "addForeignKey": return `ALTER TABLE ${tableName(operation.table)} ADD CONSTRAINT ${q(operation.foreignKey.name)} FOREIGN KEY (${operation.foreignKey.columns.map(q).join(", ")}) REFERENCES ${q(operation.foreignKey.target.schema)}.${q(operation.foreignKey.target.table)} (${operation.foreignKey.targetColumns.map(q).join(", ")}) ON DELETE ${action(operation.foreignKey.onDelete)} ON UPDATE ${action(operation.foreignKey.onUpdate)}`;
-    case "createIndex": return `CREATE ${operation.index.unique ? "UNIQUE " : ""}INDEX ${q(operation.index.name)} ON ${tableName(operation.table)} (${operation.index.columns.map(q).join(", ")})`;
+    case "createIndex": return `CREATE ${operation.index.unique ? "UNIQUE " : ""}INDEX ${q(operation.index.name)} ON ${tableName(operation.table)} (${operation.index.columns.map(q).join(", ")})${operation.index.predicate === undefined ? "" : ` WHERE ${renderCheck(operation.index.predicate, q)}`}`;
   }
 }
 function createTable(table: ExpectedTable): string {

package/library/orm/Schema/SchemaAdmission.ts

@@ -2,7 +2,8 @@ import type { DatabaseProvider, SchemaAdmissionScope } from "../Providers/types"
 import { SchemaAdmissionError, SchemaMigrationRequiredError, SchemaVerificationError } from "../errors";
 import type { OrmModel } from "../Metadata/OrmModel";
 import { compileExpectedSchema, type OrmExpectedSchema } from "./ExpectedSchema";
-import { ExactSchemaVerifier, type SchemaVerificationResult } from "./ExactSchemaVerifier";
+import { ExactSchemaVerifier, samePredicate, type SchemaVerificationResult } from "./ExactSchemaVerifier";
+import { renderCheck } from "./CheckExpression";
 import { classifySafeAdditive, renderSafeAdditivePostgres, type SafeAdditiveSchemaOperation } from "./SafeAdditiveSchema";
 import type { IntrospectedSchema } from "./introspection";
 
@@ -113,7 +114,7 @@ function describeOperation(operation: SafeAdditiveSchemaOperation): string {
     case "addColumn": return `add column ${tableName(operation.table.schema, operation.table.table)}.${operation.column.column}`;
     case "addCheck": return `add check ${operation.check.name} on ${tableName(operation.table.schema, operation.table.table)}`;
     case "addForeignKey": return `add foreign key ${operation.foreignKey.name} on ${tableName(operation.table.schema, operation.table.table)}`;
-    case "createIndex": return `create ${operation.index.unique ? "unique " : ""}index ${operation.index.name} on ${tableName(operation.table.schema, operation.table.table)} (${operation.index.columns.join(", ")})`;
+    case "createIndex": return `create ${operation.index.unique ? "unique " : ""}index ${operation.index.name} on ${tableName(operation.table.schema, operation.table.table)} (${operation.index.columns.join(", ")})${operation.index.predicate === undefined ? "" : ` where ${renderCheck(operation.index.predicate, (name) => name)}`}`;
   }
 }
 
@@ -135,7 +136,7 @@ function alignIndexNames(expected: OrmExpectedSchema, actual: IntrospectedSchema
     let indexes = found.indexes;
     for (const index of table.indexes) {
       if (indexes.some((item) => item.name === index.name)) continue;
-      const match = indexes.find((item) => !item.backingConstraint && !item.unsupported && !item.predicate && item.method === "btree" && !expectedNames.has(item.name)
+      const match = indexes.find((item) => !item.backingConstraint && !item.unsupported && samePredicate(item.predicate, index.predicate) && item.method === "btree" && !expectedNames.has(item.name)
         && item.unique === index.unique && item.columns.length === index.columns.length && item.columns.every((column, position) => column === index.columns[position]));
       if (!match) continue;
       warnings.push(`table ${quote(table.schema)}.${quote(table.table)}: index is named ${quote(match.name)}, the model expects ${quote(index.name)}. `

package/library/orm/Schema/SchemaDiffer.ts

@@ -1,6 +1,8 @@
 import { entityStorageKey } from "./tableKey";
 import type { ColumnType, EntityModel, IndexModel, PropertyModel } from "../Metadata/types";
 import type { IntrospectedSchema, IntrospectedTable } from "./introspection";
+import { projectCheckAstIdentifiers, type CheckAst } from "./CheckExpression";
+import { samePredicate } from "./ExactSchemaVerifier";
 
 /**
  * Additive schema change operation. Destructive changes (drop/type change) never
@@ -89,7 +91,7 @@ export class SchemaDiffer {
     for (const index of model.indexes) {
       if (existing.has(index.name)) continue;
       // The same index under another name (for example from before 0.98.20) is not duplicated.
-      const renamed = table.indexes.find((item) => !declared.has(item.name) && !item.backingConstraint && !item.predicate && item.unique === index.unique
+      const renamed = table.indexes.find((item) => !declared.has(item.name) && !item.backingConstraint && !item.unsupported && samePredicate(item.predicate, projectedWhere(model, index)) && item.unique === index.unique
         && item.columns.length === index.columns.length && item.columns.every((column, position) => column === index.columns[position]));
       if (renamed) {
         warnings.push(`table "${model.tableName}": index "${renamed.name}" matches "${index.name}" from the model except for its name (left untouched; to align it run: ALTER INDEX "${renamed.name}" RENAME TO "${index.name}";).`);
@@ -99,3 +101,8 @@ export class SchemaDiffer {
     }
   }
 }
+
+/** The index condition over column names, as the catalog reports it. */
+function projectedWhere(model: EntityModel, index: EntityModel["indexes"][number]): CheckAst | undefined {
+  return index.where === undefined ? undefined : projectCheckAstIdentifiers(index.where, (name) => model.propertyByName(name)!.columnName);
+}

package/library/orm/Schema/formatSchemaDifferences.ts

@@ -18,6 +18,7 @@ const descriptions: Record<SchemaDifferenceCode, string> = {
   "index.columns": "index columns or their order differ",
   "index.uniqueness": "index uniqueness differs",
   "index.method": "index method differs",
+  "index.predicate": "partial index condition (where) differs",
   "index.unsupportedShape": "index shape is unsupported by exact schema admission",
   "foreignKey.missing": "foreign key is missing",
   "foreignKey.unexpected": "foreign key is not declared in the ORM model",

package/library/orm/Schema/introspection.ts

@@ -1,3 +1,4 @@
+import type { CheckAst } from "./CheckExpression";
 /**
  * Snapshot of the actual database schema obtained by introspection. The source
  * of the "current" state for the additive auto-migration (the target is the
@@ -22,7 +23,8 @@ export interface IntrospectedIndex {
   readonly unique: boolean;
   readonly method?: "btree";
   readonly backingConstraint?: boolean;
-  readonly predicate?: string;
+  /** Partial index condition read from the catalog; unreadable ones mark the index `unsupported`. */
+  readonly predicate?: CheckAst;
   readonly unsupported?: boolean;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.114.0",
+  "version": "0.115.0",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",