@rebasepro/types 0.8.0 → 0.9.1-canary.09aaf62

package/src/types/data_source.ts

@@ -1,3 +1,5 @@
+import { ALL_WHERE_FILTER_OPS, WhereFilterOp } from "./filter-operators";
+
 /**
  * Describes the capabilities and features supported by a data source (driver).
  *
@@ -35,6 +37,17 @@ export interface DataSourceCapabilities {
     /** Does this source support real-time listeners? */
     supportsRealtime: boolean;
 
+    /**
+     * Canonical filter operators this engine can execute.
+     *
+     * The admin UI intersects this set with the property-type defaults and
+     * any per-property narrowing (`property.ui.filterOperators`) to decide
+     * which operators to offer in filter fields — so an engine that cannot
+     * run `ilike` (e.g. Firestore) never shows a "Contains" filter that
+     * would throw at query time.
+     */
+    filterOperators: readonly WhereFilterOp[];
+
     // ── Admin capability flags ───────────────────────────────────────
     /** Does this source support SQL admin operations (SQL editor, EXPLAIN, etc.)? */
     supportsSQLAdmin: boolean;
@@ -102,9 +115,11 @@ export interface DataSourceDefinition {
     engine: string;
 
     /**
-     * How the frontend reaches this source. Defaults to `"server"`.
+     * How the frontend reaches this source. Optional — when omitted it is
+     * inferred: `"direct"` if the definition carries a client-side driver,
+     * `"server"` otherwise.
      */
-    transport: DataSourceTransport;
+    transport?: DataSourceTransport;
 
     /**
      * The physical database/schema/Firestore-database within the engine.
@@ -149,6 +164,7 @@ export const POSTGRES_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: false,
     supportsColumnTypes: true,
     supportsRealtime: true,
+    filterOperators: ALL_WHERE_FILTER_OPS,
     supportsSQLAdmin: true,
     supportsDocumentAdmin: false,
     supportsSchemaAdmin: true
@@ -164,6 +180,10 @@ export const FIREBASE_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: true,
     supportsColumnTypes: false,
     supportsRealtime: true,
+    // Firestore has no SQL pattern matching — the driver throws on the LIKE
+    // family, so the UI must never offer it.
+    filterOperators: ALL_WHERE_FILTER_OPS.filter(op =>
+        op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
     supportsSQLAdmin: false,
     supportsDocumentAdmin: false,
     supportsSchemaAdmin: false
@@ -179,6 +199,7 @@ export const MONGODB_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: true,
     supportsColumnTypes: false,
     supportsRealtime: false,
+    filterOperators: ALL_WHERE_FILTER_OPS,
     supportsSQLAdmin: false,
     supportsDocumentAdmin: true,
     supportsSchemaAdmin: true
@@ -198,6 +219,7 @@ export const DEFAULT_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: true,
     supportsColumnTypes: true,
     supportsRealtime: true,
+    filterOperators: ALL_WHERE_FILTER_OPS,
     supportsSQLAdmin: true,
     supportsDocumentAdmin: true,
     supportsSchemaAdmin: true

package/src/types/database_adapter.ts

@@ -9,7 +9,7 @@
  *
  * @example
  * ```ts
- * import { createPostgresAdapter } from "@rebasepro/server-postgresql";
+ * import { createPostgresAdapter } from "@rebasepro/server-postgres";
  *
  * initializeRebaseBackend({
  *   database: createPostgresAdapter({ connection: db, schema }),
@@ -21,7 +21,7 @@
  */
 
 import type { DataDriver } from "../controllers/data_driver";
-import type { EntityCollection } from "./collections";
+import type { CollectionConfig } from "./collections";
 import type {
     CollectionRegistryInterface,
     DatabaseAdmin,
@@ -29,6 +29,7 @@ import type {
     RealtimeProvider,
     BootstrappedAuth
 } from "./backend";
+import type { HistoryConfig } from "../controllers/client";
 
 /**
  * A `DatabaseAdapter` provides data persistence for Rebase.
@@ -75,7 +76,7 @@ export interface DatabaseAdapter {
      * Return `undefined` if the database does not support history.
      */
     initializeHistory?(
-        config: unknown,
+        config: HistoryConfig,
         driverResult: InitializedDriver,
     ): Promise<{ historyService: unknown } | undefined>;
 
@@ -114,7 +115,21 @@ export interface DatabaseAdapter {
  */
 export interface DatabaseAdapterInitConfig {
     /** Registered collection definitions. */
-    collections: EntityCollection[];
+    collections: CollectionConfig[];
     /** The shared collection registry to register into. */
     collectionRegistry: CollectionRegistryInterface;
+    /**
+     * How the server is being run — see `RebaseBackendConfig.mode`.
+     *
+     * In `"baas"` mode `collections` is empty by design: a driver that can
+     * describe its own schema should introspect the database and report the
+     * collections it found back on `InitializedDriver.collections`. Drivers
+     * that cannot introspect may ignore this.
+     */
+    mode?: "cms" | "baas";
+    /**
+     * `baas`-mode options — see `RebaseBackendConfig.baas`. Drivers that
+     * introspect should honour `unprotectedTables`.
+     */
+    baas?: { unprotectedTables?: "exclude" | "serve" };
 }

package/src/types/entities.ts

@@ -5,7 +5,7 @@
 export type EntityStatus = "new" | "existing" | "copy";
 
 /**
- * Representation of an entity fetched from the driver
+ * Representation of a entity fetched from the driver
  * @group Models
  */
 export interface Entity<M extends Record<string, unknown> = Record<string, unknown>> {
@@ -47,7 +47,7 @@ export interface Entity<M extends Record<string, unknown> = Record<string, unkno
 export type EntityValues<M extends Record<string, unknown>> = M;
 
 /**
- * Props for creating an EntityReference
+ * Props for creating a EntityReference
  */
 export interface EntityReferenceProps {
     /** ID of the entity */
@@ -61,7 +61,7 @@ export interface EntityReferenceProps {
 }
 
 /**
- * Class used to create a reference to an entity in a different path.
+ * Class used to create a reference to a entity in a different path.
  *
  * @example
  * // Simple reference (most common case - single driver, single db)
@@ -99,7 +99,7 @@ export class EntityReference {
     readonly databaseId?: string;
 
     /**
-     * Create a reference to an entity.
+     * Create a reference to a entity.
      *
      * @example
      * // Simple reference (most common case)
@@ -148,7 +148,7 @@ export class EntityReference {
 }
 
 /**
- * Class used to create a reference to an entity in a different path
+ * Class used to create a reference to a entity in a different path
  */
 export class EntityRelation {
 
@@ -167,9 +167,9 @@ export class EntityRelation {
      * Pre-fetched data payload to eliminate N+1 queries.
      * When present, clients can use this directly instead of fetching.
      */
-    readonly data?: Entity;
+    readonly data?: Record<string, unknown>;
 
-    constructor(id: string | number, path: string, data?: Entity) {
+    constructor(id: string | number, path: string, data?: Record<string, unknown>) {
         this.id = id;
         this.path = path;
         this.data = data;

package/src/types/entity_actions.tsx

@@ -1,13 +1,13 @@
 import React from "react";
 import type { Entity } from "./entities";
-import type { EntityCollection, SelectionController } from "./collections";
+import type { CollectionConfig, SelectionController } from "./collections";
 import type { FormContext } from "./entity_views";
 import type { User } from "../users";
 import type { RebaseContext } from "../rebase_context";
-import type { SideEntityController } from "../controllers/side_entity_controller";
+import type { SidePanelController } from "../controllers/side_panel_controller";
 
 /**
- * An entity action is a custom action that can be performed on an entity.
+ * A entity action is a custom action that can be performed on a entity.
  * They are displayed in the entity view and in the collection view.
  */
 export interface EntityAction<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
@@ -72,7 +72,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     context?: RebaseContext<USER>;
 
     path?: string;
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
 
     /**
      * Optional form context, present if the action is being called from a form.
@@ -83,7 +83,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     /**
      * Present if this actions is being called from a side dialog only
      */
-    sideEntityController?: SideEntityController;
+    sidePanelController?: SidePanelController;
 
     /**
      * Is the action being called from the collection view or from the entity form view?
@@ -113,12 +113,12 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     unhighlightEntity?: (entity: Entity<Record<string, unknown>>) => void;
 
     /**
-     * Optional function to navigate back (e.g. when deleting an entity or navigating from a form)
+     * Optional function to navigate back (e.g. when deleting a entity or navigating from a form)
      */
     navigateBack?: () => void;
 
     /**
-     * Callback to be called when the collection changes, e.g. after an entity is deleted or created.
+     * Callback to be called when the collection changes, e.g. after a entity is deleted or created.
      */
     onCollectionChange?: () => void;
 

package/src/types/entity_callbacks.ts

@@ -1,5 +1,5 @@
-import type { EntityCollection } from "./collections";
-import type { Entity, EntityStatus, EntityValues } from "./entities";
+import type { CollectionConfig } from "./collections";
+import type { EntityStatus, EntityValues } from "./entities";
 import type { User } from "../users";
 import type { RebaseCallContext } from "../rebase_context";
 
@@ -7,7 +7,7 @@ import type { RebaseCallContext } from "../rebase_context";
  * Lifecycle callbacks for entity CRUD operations.
  *
  * Register per-collection on the collection's `callbacks` field, or globally
- * via `initBackend({ callbacks })`. Fires on **every** data path — REST API,
+ * via `initializeRebaseBackend({ callbacks })`. Fires on **every** data path — REST API,
  * WebSocket / realtime subscriptions, and server-side `rebase.data`.
  *
  * When both global and per-collection callbacks are registered, execution
@@ -15,7 +15,7 @@ import type { RebaseCallContext } from "../rebase_context";
  *
  * @group Models
  */
-export type EntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = {
+export type CollectionCallbacks<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = {
 
     /**
      * Callback used after fetching data.
@@ -25,19 +25,19 @@ export type EntityCallbacks<M extends Record<string, unknown> = Record<string, u
      *
      * @param props
      */
-    afterRead?(props: EntityAfterReadProps<M, USER>)
-        : Promise<Entity<M>> | Entity<M>;
+    afterRead?(props: AfterReadProps<M, USER>)
+        : Promise<Record<string, unknown>> | Record<string, unknown>;
 
 
     /**
      * Callback used before saving, you need to return the values that will get
      * saved. If you throw an error in this method the process stops, and an
-     * error snackbar gets displayed.
+     * HTTP error response is returned to the client.
      * This runs after schema validation.
      *
      * @param props
      */
-    beforeSave?(props: EntityBeforeSaveProps<M, USER>)
+    beforeSave?(props: BeforeSaveProps<M, USER>)
         : Promise<Partial<EntityValues<M>>> | Partial<EntityValues<M>>;
 
     /**
@@ -45,44 +45,44 @@ export type EntityCallbacks<M extends Record<string, unknown> = Record<string, u
      *
      * @param props
      */
-    afterSave?(props: EntityAfterSaveProps<M, USER>)
+    afterSave?(props: AfterSaveProps<M, USER>)
         : Promise<void> | void;
 
     /**
      * Callback used when saving fails
      * @param props
      */
-    afterSaveError?(props: EntityAfterSaveErrorProps<M, USER>)
+    afterSaveError?(props: AfterSaveErrorProps<M, USER>)
         : Promise<void> | void;
 
     /**
      * Callback used before the entity is deleted.
      * If you throw an error in this method the process stops, and an
-     * error snackbar gets displayed.
+     * HTTP error response is returned to the client.
      *
      * @param props
      */
-    beforeDelete?(props: EntityBeforeDeleteProps<M, USER>): Promise<boolean | void> | boolean | void;
+    beforeDelete?(props: BeforeDeleteProps<M, USER>): Promise<boolean | void> | boolean | void;
 
     /**
      * Callback used after the entity is deleted.
      *
      * @param props
      */
-    afterDelete?(props: EntityAfterDeleteProps<M, USER>): Promise<void> | void;
+    afterDelete?(props: AfterDeleteProps<M, USER>): Promise<void> | void;
 
 }
 
 /**
- * Parameters passed to hooks when an entity is fetched
+ * Parameters passed to hooks when a entity is fetched
  * @group Models
  */
-export interface EntityAfterReadProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface AfterReadProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
 
     /**
      * Collection of the entity
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 
     /**
      * Full path of the CMS where this collection is being fetched.
@@ -91,9 +91,9 @@ export interface EntityAfterReadProps<M extends Record<string, unknown> = Record
     path: string;
 
     /**
-     * Fetched entity
+     * Fetched row (flat — the table's columns)
      */
-    entity: Entity<M>
+    row: Record<string, unknown>
 
     /**
      * Context of the app status
@@ -102,34 +102,34 @@ export interface EntityAfterReadProps<M extends Record<string, unknown> = Record
 }
 
 /**
- * Parameters passed to hooks before an entity is saved
+ * Parameters passed to hooks before a entity is saved
  * @group Models
  */
-export type EntityBeforeSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> =
-    Omit<EntityAfterSaveProps<M, USER>, "entityId">
+export type BeforeSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> =
+    Omit<AfterSaveProps<M, USER>, "id">
     & {
-        entityId?: string | number;
+        id?: string | number;
     }
 /**
- * Parameters passed to hooks before an entity is saved
+ * Parameters passed to hooks before a entity is saved
  * @group Models
  */
-export type EntityAfterSaveErrorProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> =
-    Omit<EntityAfterSaveProps<M, USER>, "entityId">
+export type AfterSaveErrorProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> =
+    Omit<AfterSaveProps<M, USER>, "id">
     & {
-        entityId?: string | number;
+        id?: string | number;
     }
 
 /**
- * Parameters passed to hooks when an entity is saved
+ * Parameters passed to hooks when a entity is saved
  * @group Models
  */
-export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface AfterSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
 
     /**
      * Resolved collection of the entity
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 
     /**
      * Full path of the CMS where this entity is being saved.
@@ -140,7 +140,7 @@ export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record
     /**
      * ID of the entity
      */
-    entityId: string | number;
+    id: string | number;
 
     /**
      * Values being saved
@@ -164,15 +164,15 @@ export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record
 }
 
 /**
- * Parameters passed to hooks when an entity is deleted
+ * Parameters passed to hooks when a entity is deleted
  * @group Models
  */
-export interface EntityBeforeDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface BeforeDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
 
     /**
      * collection of the entity being deleted
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 
     /**
      * Path of the parent collection
@@ -182,12 +182,12 @@ export interface EntityBeforeDeleteProps<M extends Record<string, unknown> = Rec
     /**
      * Deleted entity id
      */
-    entityId: string | number;
+    id: string | number;
 
     /**
-     * Deleted entity
+     * Deleted row (flat — the table's columns)
      */
-    entity: Entity<M>;
+    row: Record<string, unknown>;
 
     /**
      * Context of the app status
@@ -196,15 +196,15 @@ export interface EntityBeforeDeleteProps<M extends Record<string, unknown> = Rec
 }
 
 /**
- * Parameters passed to hooks after an entity is deleted
+ * Parameters passed to hooks after a entity is deleted
  * @group Models
  */
-export interface EntityAfterDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface AfterDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
 
     /**
      * collection of the entity being deleted
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 
     /**
      * Path of the parent collection
@@ -214,12 +214,12 @@ export interface EntityAfterDeleteProps<M extends Record<string, unknown> = Reco
     /**
      * Deleted entity id
      */
-    entityId: string | number;
+    id: string | number;
 
     /**
-     * Deleted entity
+     * Deleted row (flat — the table's columns)
      */
-    entity: Entity<M>;
+    row: Record<string, unknown>;
 
     /**
      * Context of the app status

package/src/types/entity_views.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import type { Entity, EntityValues } from "./entities";
-import type { EntityCollection } from "./collections";
+import type { CollectionConfig } from "./collections";
 import type { FormexController } from "./formex";
 import type { ComponentRef } from "./component_ref";
 
@@ -37,7 +37,7 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
     /**
      * Collection of the entity being modified
      */
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
 
     /**
      * Entity id, it can be undefined if it's a new entity
@@ -105,7 +105,7 @@ export type FormViewConfig<M extends Record<string, unknown> = Record<string, un
 };
 
 export interface EntityCustomViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     entity?: Entity<M>;
     modifiedValues?: EntityValues<M>;
     formContext: FormContext<M>;

package/src/types/filter-operators.ts

@@ -8,24 +8,50 @@
  * HTTP wire boundary, handled by `serializeFilter` / `deserializeFilter`
  * in `@rebasepro/common`.
  *
- * ┌──────────────────┬───────────────┬──────────────────────────┐
- * │ Canonical        │ REST short    │ Meaning                  │
- * ├──────────────────┼───────────────┼──────────────────────────┤
- * │ "=="             │ "eq"          │ Equal                    │
- * │ "!="             │ "neq"         │ Not equal                │
- * │ ">"              │ "gt"          │ Greater than             │
- * │ ">="             │ "gte"         │ Greater than or equal    │
- * │ "<"              │ "lt"          │ Less than                │
- * │ "<="             │ "lte"         │ Less than or equal       │
- * │ "in"             │ "in"          │ Value in list            │
- * │ "not-in"         │ "nin"         │ Value not in list        │
- * │ "array-contains" │ "cs"          │ Array contains element   │
- * │ "array-contains-any" │ "csa"     │ Array contains any of    │
- * └──────────────────┴───────────────┴──────────────────────────┘
+ * ┌──────────────────────┬───────────────┬──────────────────────────────┐
+ * │ Canonical            │ REST short    │ Meaning                      │
+ * ├──────────────────────┼───────────────┼──────────────────────────────┤
+ * │ "=="                 │ "eq"          │ Equal                        │
+ * │ "!="                 │ "neq"         │ Not equal                    │
+ * │ ">"                  │ "gt"          │ Greater than                 │
+ * │ ">="                 │ "gte"         │ Greater than or equal        │
+ * │ "<"                  │ "lt"          │ Less than                    │
+ * │ "<="                 │ "lte"         │ Less than or equal           │
+ * │ "in"                 │ "in"          │ Value in list                │
+ * │ "not-in"             │ "nin"         │ Value not in list            │
+ * │ "array-contains"     │ "cs"          │ Array contains element       │
+ * │ "array-contains-any" │ "csa"         │ Array contains any of        │
+ * │ "like"               │ "like"        │ SQL LIKE (case-sensitive)    │
+ * │ "ilike"              │ "ilike"       │ SQL ILIKE (case-insensitive) │
+ * │ "not-like"           │ "nlike"       │ NOT LIKE (case-sensitive)    │
+ * │ "not-ilike"          │ "nilike"      │ NOT ILIKE (case-insensitive) │
+ * │ "is-null"            │ "isnull"      │ Field IS NULL                │
+ * │ "is-not-null"        │ "notnull"     │ Field IS NOT NULL            │
+ * └──────────────────────┴───────────────┴──────────────────────────────┘
+ *
+ * Pattern matching (`like`/`ilike`) uses SQL wildcard syntax: `%` matches any
+ * sequence of characters, `_` matches a single character. On MongoDB these are
+ * translated to anchored regular expressions; Firestore has no native pattern
+ * matching and rejects these operators (use `searchString` instead).
  *
  * @module
  */
 
+/**
+ * Canonical sort representation: `[fieldName, direction]`.
+ *
+ * Used in `FindParams.orderBy`, `collection.sort`, and `FilterPreset.sort`.
+ * The colon-string form (`"field:direction"`) exists only at the HTTP wire
+ * boundary, handled by `serializeOrderBy` / `deserializeOrderBy` in
+ * `@rebasepro/common`.
+ *
+ * Design note: the natural extension for multi-column sort is
+ * `OrderByTuple[]` — not implemented yet (server consumes only the first).
+ *
+ * @group Models
+ */
+export type OrderByTuple<Key extends string = string> = [Key, "asc" | "desc"];
+
 /**
  * Canonical filter operators supported across all database backends.
  * Each DB driver translates these to its native query format.
@@ -42,7 +68,13 @@ export type WhereFilterOp =
     | "array-contains"
     | "in"
     | "not-in"
-    | "array-contains-any";
+    | "array-contains-any"
+    | "like"
+    | "ilike"
+    | "not-like"
+    | "not-ilike"
+    | "is-null"
+    | "is-not-null";
 
 /**
  * Used to define filters applied in collections.
@@ -61,6 +93,14 @@ export type WhereFilterOp =
  * { role: ["in", ["admin", "editor"]] }
  * { tags: ["array-contains", "featured"] }
  *
+ * // Pattern matching (SQL wildcards: % and _)
+ * { name: ["ilike", "%john%"] }
+ * { slug: ["like", "post-%"] }
+ *
+ * // Null checks (the value is ignored; `null` is conventional)
+ * { deleted_at: ["is-null", null] }
+ * { published_at: ["is-not-null", null] }
+ *
  * @group Models
  */
 export type FilterValues<Key extends string> =
@@ -101,7 +141,7 @@ export interface FilterPreset<Key extends string = string> {
     /**
      * Optional sort override to apply alongside the filter values.
      */
-    sort?: [Key, "asc" | "desc"];
+    sort?: OrderByTuple<Key>;
 }
 
 /**
@@ -114,7 +154,10 @@ export type RestFilterOp =
     | "gt" | "gte"
     | "lt" | "lte"
     | "in" | "nin"
-    | "cs" | "csa";
+    | "cs" | "csa"
+    | "like" | "ilike"
+    | "nlike" | "nilike"
+    | "isnull" | "notnull";
 
 /** Maps canonical operators to their REST short-code equivalents. */
 export const CANONICAL_TO_REST: Readonly<Record<WhereFilterOp, RestFilterOp>> = {
@@ -127,7 +170,13 @@ export const CANONICAL_TO_REST: Readonly<Record<WhereFilterOp, RestFilterOp>> =
     "in": "in",
     "not-in": "nin",
     "array-contains": "cs",
-    "array-contains-any": "csa"
+    "array-contains-any": "csa",
+    "like": "like",
+    "ilike": "ilike",
+    "not-like": "nlike",
+    "not-ilike": "nilike",
+    "is-null": "isnull",
+    "is-not-null": "notnull"
 };
 
 /** Maps REST short-code operators to their canonical equivalents. */
@@ -141,15 +190,39 @@ export const REST_TO_CANONICAL: Readonly<Record<RestFilterOp, WhereFilterOp>> =
     "in": "in",
     "nin": "not-in",
     "cs": "array-contains",
-    "csa": "array-contains-any"
+    "csa": "array-contains-any",
+    "like": "like",
+    "ilike": "ilike",
+    "nlike": "not-like",
+    "nilike": "not-ilike",
+    "isnull": "is-null",
+    "notnull": "is-not-null"
 };
 
-/** All canonical operator strings for runtime validation. */
-const CANONICAL_OPS: ReadonlySet<string> = new Set<WhereFilterOp>([
+/**
+ * Operators that test for null/not-null and therefore ignore their value.
+ * Codecs normalize the value of these conditions to `null`.
+ */
+export const NULL_OPS: ReadonlySet<WhereFilterOp> = new Set<WhereFilterOp>([
+    "is-null", "is-not-null"
+]);
+
+/**
+ * Every canonical operator, in a stable order. Useful for engine capability
+ * declarations ({@link DataSourceCapabilities.filterOperators}) and for
+ * building operator subsets.
+ * @group Models
+ */
+export const ALL_WHERE_FILTER_OPS: readonly WhereFilterOp[] = [
     "<", "<=", "==", "!=", ">=", ">",
     "in", "not-in",
-    "array-contains", "array-contains-any"
-]);
+    "array-contains", "array-contains-any",
+    "like", "ilike", "not-like", "not-ilike",
+    "is-null", "is-not-null"
+];
+
+/** All canonical operator strings for runtime validation. */
+const CANONICAL_OPS: ReadonlySet<string> = new Set<WhereFilterOp>(ALL_WHERE_FILTER_OPS);
 
 /**
  * Resolve any operator string (canonical or REST short-code) to its