@rebasepro/common 0.1.2 → 0.2.3

package/dist/util/entities.d.ts

@@ -3,8 +3,8 @@ export declare function isReadOnly(property: Property): boolean;
 export declare function isHidden(property: Property): boolean;
 export declare function isPropertyBuilder(property?: Property): boolean;
 export declare function getDefaultValuesFor<M extends Record<string, unknown>>(properties: Properties): Partial<EntityValues<M>>;
-export declare function getDefaultValueFor(property?: Property): {} | null | undefined;
-export declare function getDefaultValueFortype(type: DataType): {} | null;
+export declare function getDefaultValueFor(property?: Property): unknown;
+export declare function getDefaultValueFortype(type: DataType): unknown;
 /**
  * Update the automatic values in an entity before save
  * @group Driver

package/dist/util/relations.d.ts

@@ -1,5 +1,5 @@
 import { EntityCollection, Property, Relation } from "@rebasepro/types";
-export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation;
+export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection, resolveCollection?: (slugOrTable: string) => EntityCollection | undefined): Relation;
 export declare function resolveCollectionRelations(collection: EntityCollection): Record<string, Relation>;
 export declare function resolvePropertyRelation({ propertyKey, property, sourceCollection }: {
     propertyKey: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.2.3",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -32,7 +32,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "development": "./src/index.ts",
+      "development": "./dist/index.es.js",
       "import": "./dist/index.es.js",
       "require": "./dist/index.umd.js"
     },
@@ -41,29 +41,27 @@
   "dependencies": {
     "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/types": "0.1.2",
-    "@rebasepro/utils": "0.1.2"
+    "@rebasepro/types": "0.2.3",
+    "@rebasepro/utils": "0.2.3"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
-    "@testing-library/react": "^16.3.0",
+    "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.17.14",
+    "@types/node": "^20.19.41",
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^19.0.8",
-    "@types/react-dom": "^19.0.3",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
     "@types/react-measure": "^2.0.12",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "^4.7.0",
     "babel-plugin-react-compiler": "beta",
     "cross-env": "^7.0.3",
-    "eslint-plugin-react-compiler": "beta",
     "jest": "^29.7.0",
-    "npm-run-all": "^4.1.5",
-    "ts-jest": "^29.3.1",
+    "ts-jest": "^29.4.10",
     "tsd": "^0.31.2",
-    "typescript": "^5.8.3",
-    "vite": "^5.4.17"
+    "typescript": "^5.9.3",
+    "vite": "^5.4.21"
   },
   "files": [
     "dist",
@@ -94,7 +92,10 @@
     ],
     "testEnvironment": "node",
     "moduleNameMapper": {
-      "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js"
+      "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js",
+      "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
+      "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
+      "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
     }
   },
   "scripts": {

package/src/collections/CollectionRegistry.ts

@@ -9,8 +9,6 @@ import {
     Relation,
     RelationProperty,
     StringProperty,
-    OnAction,
-    JoinStep,
     getDataSourceCapabilities
 } from "@rebasepro/types";
 import { deepEqual } from "fast-equals";
@@ -71,8 +69,14 @@ export class CollectionRegistry {
             return false;
         }
 
-        // Raw input has changed — normalize and register
         this.reset();
+        // Phase 0: Populate maps with raw collections first for string target resolution
+        collections.forEach((c) => {
+            if (c.slug) {
+                this.collectionsBySlug.set(c.slug, c);
+            }
+            this.collectionsByTableName.set(getTableName(c), c);
+        });
 
         const normalizedCollections = collections.map(c => this.normalizeCollection({ ...c }));
 
@@ -164,12 +168,23 @@ export class CollectionRegistry {
 
         // 2. Merge with manual relations[] (manual entries win on name conflict)
         const relResult = result as CollectionWithRelations;
-        const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? ((relResult as any).relations ?? []) : [];
+        const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? (relResult.relations ?? []) : [];
         const mergedRelationsRaw = [...extractedRelations];
         for (const manual of manualRelations) {
             const name = manual.relationName;
-            if (!name || !mergedRelationsRaw.find(r => r.relationName === name)) {
+            if (!name) {
                 mergedRelationsRaw.push(manual);
+            } else {
+                const existingIndex = mergedRelationsRaw.findIndex(r => r.relationName === name);
+                if (existingIndex === -1) {
+                    mergedRelationsRaw.push(manual);
+                } else {
+                    // Merge manual into existing, preserving custom fields like 'collection'
+                    mergedRelationsRaw[existingIndex] = {
+                        ...manual,
+                        ...mergedRelationsRaw[existingIndex]
+                    };
+                }
             }
         }
 
@@ -182,7 +197,7 @@ export class CollectionRegistry {
         if (getDataSourceCapabilities(result.driver).supportsRelations) {
             mergedRelations = mergedRelationsRaw.map(r => {
                 try {
-                    return sanitizeRelation(r, result);
+                    return sanitizeRelation(r, result, (slug) => this.get(slug));
                 } catch {
                     // sanitizeRelation may throw for incomplete configs
                     // (e.g. missing target). Keep the raw relation as-is.
@@ -191,7 +206,7 @@ export class CollectionRegistry {
             });
 
             // 3. Set the merged relations on the result copy
-            (relResult as any).relations = mergedRelations;
+            relResult.relations = mergedRelations;
         }
 
         // 4. Normalize properties (which stamps relation on each property)
@@ -202,8 +217,8 @@ export class CollectionRegistry {
         if (!result.childCollections) {
             if (getDataSourceCapabilities(result.driver).supportsSubcollections && (result as CollectionWithSubcollections).subcollections) {
                 result.childCollections = (result as CollectionWithSubcollections).subcollections;
-            } else if (getDataSourceCapabilities(result.driver).supportsRelations && (relResult as any).relations) {
-                const manyRelations = (relResult as any).relations.filter((r: Relation) => r.cardinality === "many");
+            } else if (getDataSourceCapabilities(result.driver).supportsRelations && relResult.relations) {
+                const manyRelations = relResult.relations.filter((r: Relation) => r.cardinality === "many");
                 if (manyRelations.length > 0) {
                     result.childCollections = () => manyRelations.map((r: Relation) => {
                         const target = r.target();
@@ -463,31 +478,3 @@ export class CollectionRegistry {
 
 }
 
-function areCollectionListsEqual(a: EntityCollection[], b: EntityCollection[]) {
-    // console.log("Comparing collection lists", a, b);
-    // return true;
-    if (a.length !== b.length) {
-        return false;
-    }
-    const aCopy = [...a];
-    const bCopy = [...b];
-    const aSorted = aCopy.sort((x, y) => x.slug.localeCompare(y.slug));
-    const bSorted = bCopy.sort((x, y) => x.slug.localeCompare(y.slug));
-    return aSorted.every((value, index) => areCollectionsEqual(value, bSorted[index]));
-}
-
-function areCollectionsEqual(a: EntityCollection, b: EntityCollection) {
-    const subcollectionsA = getSubcollections(a);
-    const subcollectionsB = getSubcollections(b);
-    const { driver: _dA, ...restA } = a as EntityCollection & Record<string, unknown>;
-    const { driver: _dB, ...restB } = b as EntityCollection & Record<string, unknown>;
-    // Remove subcollections/relations from comparison objects (already handled above)
-    delete restA.subcollections;
-    delete restB.subcollections;
-    delete (restA as any).relations;
-    delete (restB as any).relations;
-    if (!areCollectionListsEqual(subcollectionsA, subcollectionsB)) {
-        return false;
-    }
-    return deepEqual(removeFunctions(restA), removeFunctions(restB));
-}

package/src/data/buildRebaseData.ts

@@ -11,6 +11,7 @@ import {
     WhereFieldValue
 } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
+import { QueryBuilder } from "./query_builder";
 
 /**
  * Convert where-clause filter object to the internal DataDriver FilterValues format.
@@ -129,14 +130,11 @@ function parseOrderBy(orderBy?: string): [string, "asc" | "desc"] | undefined {
     return [field, direction];
 }
 
-/**
- * Create a CollectionAccessor that delegates to a DataDriver for a given collection slug.
- */
 function createDriverAccessor<M extends Record<string, unknown> = Record<string, unknown>>(
     driver: DataDriver,
     slug: string
 ): CollectionAccessor<M> {
-    return {
+    const accessor: CollectionAccessor<M> = {
         async find(params?: FindParams): Promise<FindResponse<M>> {
             const orderParsed = parseOrderBy(params?.orderBy);
             const entities = await driver.fetchCollection<M>({
@@ -237,8 +235,30 @@ values: {} as Record<string, unknown> }
                     onUpdate: (entity) => onUpdate(entity ?? undefined),
                     onError
                 });
-            } : undefined
+            } : undefined,
+
+        // Fluent Query Builder
+        where(column: keyof M & string, operator: any, value: unknown) {
+            return new QueryBuilder<M>(accessor).where(column, operator, value);
+        },
+        orderBy(column: keyof M & string, ascending?: "asc" | "desc") {
+            return new QueryBuilder<M>(accessor).orderBy(column, ascending);
+        },
+        limit(count: number) {
+            return new QueryBuilder<M>(accessor).limit(count);
+        },
+        offset(count: number) {
+            return new QueryBuilder<M>(accessor).offset(count);
+        },
+        search(searchString: string) {
+            return new QueryBuilder<M>(accessor).search(searchString);
+        },
+        include(...relations: string[]) {
+            return new QueryBuilder<M>(accessor).include(...relations);
+        }
     };
+
+    return accessor;
 }
 
 /**

package/src/data/query_builder.ts

@@ -0,0 +1,117 @@
+import { FindParams, Entity, FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator } from "@rebasepro/types";
+
+/**
+ * Maps standard operators to Rebase backend's string-based operators
+ */
+function mapOperator(op: FilterOperator): string {
+    switch (op) {
+        case "==": return "eq";
+        case "!=": return "neq";
+        case ">": return "gt";
+        case ">=": return "gte";
+        case "<": return "lt";
+        case "<=": return "lte";
+        case "array-contains": return "cs";
+        case "array-contains-any": return "csa";
+        case "not-in": return "nin";
+        default: return op;
+    }
+}
+
+export class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
+    private params: FindParams = { where: {} };
+
+    constructor(private collection: CollectionAccessor<M>) {}
+
+    /**
+     * Add a filter condition to your query.
+     * @example
+     * client.collection('users').where('age', '>=', 18).find()
+     */
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): this {
+        if (!this.params.where) {
+            this.params.where = {};
+        }
+
+        const mappedOp = mapOperator(operator);
+        let formattedValue = value;
+
+        // Handle arrays for in, nin, cs, csa
+        if (Array.isArray(value) && ["in", "nin", "cs", "csa"].includes(mappedOp)) {
+            formattedValue = `(${value.join(",")})`;
+        } else if (value === null) {
+            formattedValue = "null";
+        }
+
+        this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
+        return this;
+    }
+
+    /**
+     * Order the results by a specific column.
+     * @example
+     * client.collection('users').orderBy('createdAt', 'desc').find()
+     */
+    orderBy(column: keyof M & string, ascending: "asc" | "desc" = "asc"): this {
+        this.params.orderBy = `${column}:${ascending}`;
+        return this;
+    }
+
+    /**
+     * Limit the number of results returned.
+     */
+    limit(count: number): this {
+        this.params.limit = count;
+        return this;
+    }
+
+    /**
+     * Skip the first N results.
+     */
+    offset(count: number): this {
+        this.params.offset = count;
+        return this;
+    }
+
+    /**
+     * Set a free-text search string if supported by the backend.
+     */
+    search(searchString: string): this {
+        this.params.searchString = searchString;
+        return this;
+    }
+
+    /**
+     * Include related entities in the response.
+     * Relations will be populated with full entity data instead of just IDs.
+     *
+     * @param relations - Relation names to include, or "*" for all.
+     * @example
+     * // Include specific relations
+     * client.data.posts.include("tags", "author").find()
+     *
+     * // Include all relations
+     * client.data.posts.include("*").find()
+     */
+    include(...relations: string[]): this {
+        this.params.include = relations;
+        return this;
+    }
+
+    /**
+     * Execute the find query and return the results.
+     */
+    async find(): Promise<FindResponse<M>> {
+        return this.collection.find(this.params) as Promise<FindResponse<M>>;
+    }
+
+    /**
+     * Listen to realtime updates matching this query.
+     */
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void {
+        if (!this.collection.listen) {
+            throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
+        }
+        return this.collection.listen(this.params, onUpdate, onError);
+    }
+}

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from "./util";
 export * from "./collections";
 export * from "./data/buildRebaseData";
+export * from "./data/query_builder";
+

package/src/types/json-logic-js.d.ts

@@ -1,7 +1,7 @@
 declare module "json-logic-js" {
     interface JsonLogic {
         apply(logic: unknown, data?: unknown): unknown;
-        add_operation<T extends any[]>(name: string, fn: (...args: T) => unknown): void;
+        add_operation<T extends unknown[]>(name: string, fn: (...args: T) => unknown): void;
     }
     const jsonLogic: JsonLogic;
     export default jsonLogic;

package/src/util/builders.ts

@@ -50,6 +50,7 @@ export function buildProperty<T, P extends Property = Property>(
     P extends ArrayProperty ? ArrayProperty :
     P extends MapProperty ? MapProperty : never {
 
+    // SAFETY: Identity function — P is a subtype of the conditional return type by definition
     return property as unknown as ReturnType<typeof buildProperty<T, P>>;
 }
 

package/src/util/entities.ts

@@ -44,7 +44,7 @@ export function getDefaultValuesFor<M extends Record<string, unknown>>(propertie
 ...b }), {}) as EntityValues<M>;
 }
 
-export function getDefaultValueFor(property?: Property) {
+export function getDefaultValueFor(property?: Property): unknown {
     if (!property) return undefined;
     if (isPropertyBuilder(property)) return undefined;
     if (property.defaultValue || property.defaultValue === null) {
@@ -58,7 +58,7 @@ export function getDefaultValueFor(property?: Property) {
     }
 }
 
-export function getDefaultValueFortype(type: DataType) {
+export function getDefaultValueFortype(type: DataType): unknown {
     if (type === "string") {
         return null;
     } else if (type === "number") {
@@ -71,6 +71,10 @@ export function getDefaultValueFortype(type: DataType) {
         return [];
     } else if (type === "map") {
         return {};
+    } else if (type === "vector") {
+        return null;
+    } else if (type === "binary") {
+        return null;
     } else {
         return null;
     }

package/src/util/relations.ts

@@ -2,14 +2,60 @@ import { CollectionWithRelations, EntityCollection, getDataSourceCapabilities, P
 import { toSnakeCase } from "@rebasepro/utils";
 import { generateForeignKeyName } from "@rebasepro/utils";
 
-export function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation {
+export function sanitizeRelation(
+    relation: Partial<Relation>,
+    sourceCollection: EntityCollection,
+    resolveCollection?: (slugOrTable: string) => EntityCollection | undefined
+): Relation {
     if (!relation.target) {
         throw new Error("Relation is missing a `target` collection.");
     }
-    const targetCollection = relation.target();
+
+    const rawTarget = relation.target;
+    let targetCollection: EntityCollection | undefined;
+
+    if (typeof rawTarget === "string") {
+        if (resolveCollection) {
+            targetCollection = resolveCollection(rawTarget);
+        }
+        if (!targetCollection) {
+            targetCollection = { slug: rawTarget, name: rawTarget } as EntityCollection;
+        }
+    } else if (typeof rawTarget === "function") {
+        const evaluated = rawTarget();
+        if (typeof evaluated === "string") {
+            if (resolveCollection) {
+                targetCollection = resolveCollection(evaluated);
+            }
+            if (!targetCollection) {
+                targetCollection = { slug: evaluated, name: evaluated } as EntityCollection;
+            }
+        } else {
+            targetCollection = evaluated;
+        }
+    } else if (rawTarget && typeof rawTarget === "object") {
+        targetCollection = rawTarget as EntityCollection;
+    }
+
+    if (!targetCollection) {
+        throw new Error("Relation is missing a valid `target` collection.");
+    }
 
     const newRelation: Partial<Relation> = { ...relation };
 
+    newRelation.target = () => {
+        if (typeof rawTarget === "string") {
+            return (resolveCollection && resolveCollection(rawTarget)) || targetCollection!;
+        } else if (typeof rawTarget === "function") {
+            const evaluated = rawTarget();
+            if (typeof evaluated === "string") {
+                return (resolveCollection && resolveCollection(evaluated)) || targetCollection!;
+            }
+            return evaluated;
+        }
+        return targetCollection!;
+    };
+
     // 1. Default relationName from target collection slug
     if (!newRelation.relationName) {
         newRelation.relationName = toSnakeCase(targetCollection.slug);
@@ -41,7 +87,7 @@ export function sanitizeRelation(relation: Partial<Relation>, sourceCollection:
 
                 try {
                     // Look for an owning relation on the target that points back to this collection
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as any).relations) || []) : [];
+                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as CollectionWithRelations).relations) || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.direction === "owning" &&
                             targetRel.cardinality === "one" &&
@@ -85,16 +131,33 @@ export function sanitizeRelation(relation: Partial<Relation>, sourceCollection:
                     // Note: we intentionally do NOT require `through` here because the raw (unsanitized)
                     // relations won't have `through` populated yet — sanitizeRelation fills it in later.
                     // `cardinality: "many" + direction: "owning"` is sufficient to identify owning M2M.
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as any).relations) || []) : [];
+
+                    // 1. Check the explicit relations[] array
+                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as CollectionWithRelations).relations) || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.cardinality === "many" &&
                             (targetRel.direction === "owning" || !targetRel.direction) &&
                             (targetRel.relationName === newRelation.inverseRelationName)) {
-                            // Found a corresponding owning many-to-many relation
                             isManyToManyInverse = true;
                             break;
                         }
                     }
+
+                    // 2. Also check the target's properties for inline relation definitions
+                    //    (e.g. posts.properties.tags = { type: "relation", cardinality: "many", direction: "owning" })
+                    if (!isManyToManyInverse && targetCollection.properties) {
+                        for (const [propKey, prop] of Object.entries(targetCollection.properties)) {
+                            if ((prop as Property).type !== "relation") continue;
+                            const relProp = prop as RelationProperty;
+                            const relName = relProp.relationName || propKey;
+                            if (relName === newRelation.inverseRelationName &&
+                                relProp.cardinality === "many" &&
+                                (relProp.direction === "owning" || !relProp.direction)) {
+                                isManyToManyInverse = true;
+                                break;
+                            }
+                        }
+                    }
                 } catch (e) {
                     // If we can't inspect the target collection, assume one-to-many
                 }
@@ -152,13 +215,17 @@ export function resolveCollectionRelations(
 
     // 1. Process explicit relations from the `relations` field.
     //    Each relation is stored once under its canonical relationName key.
-    if ((relCollection as any).relations) {
-        (relCollection as any).relations.forEach((relation: Relation) => {
-            const normalizedRelation = sanitizeRelation(relation, collection);
-            const relationKey = normalizedRelation.relationName;
-            if (relationKey) {
-                relations[relationKey] = normalizedRelation;
-                registeredRelationNames.add(relationKey);
+    if (relCollection.relations) {
+        relCollection.relations.forEach((relation: Relation) => {
+            try {
+                const normalizedRelation = sanitizeRelation(relation, collection);
+                const relationKey = normalizedRelation.relationName;
+                if (relationKey) {
+                    relations[relationKey] = normalizedRelation;
+                    registeredRelationNames.add(relationKey);
+                }
+            } catch (e) {
+                // Ignore incomplete or invalid relations (e.g. missing target during registry setup)
             }
         });
     }
@@ -213,7 +280,8 @@ export function resolvePropertyRelation({
 
     const relProp = property as RelationProperty;
 
-    // 1. If the property has inline config (target set), build a Relation from it
+    // If the property has inline config (target set), build a Relation from it.
+    // We only support the flat format where properties are directly on the RelationProperty.
     if (relProp.target) {
         return {
             relationName: relProp.relationName || propertyKey,
@@ -231,15 +299,8 @@ export function resolvePropertyRelation({
         } as Relation;
     }
 
-    // 2. Fall back to lookup from collection.relations[] (backward compat)
-    const relation = (((sourceCollection as any).relations) ?? []).find((rel: Relation) => rel.relationName === relProp.relationName)
-    if (!relation) {
-        console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
-        return undefined;
-    }
-
-    return relation as Relation;
-
+    console.warn(`Unrecognized or missing relation target for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
+    return undefined;
 }
 
 export function getTableName(collection: EntityCollection): string {

package/src/util/resolutions.ts

@@ -21,6 +21,7 @@ import { enumToObjectEntries } from "./enums";
 import { DEFAULT_ONE_OF_TYPE } from "./common";
 import { isDefaultFieldConfigId } from "@rebasepro/utils";
 import { getIn, mergeDeep } from "@rebasepro/utils";
+import { resolveCollectionRelations } from "./relations";
 
 /**
  * Resolve property builders, enums and arrays.
@@ -350,8 +351,10 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
         return (collection as CollectionWithSubcollections).subcollections!() ?? [];
     }
 
-    if (getDataSourceCapabilities(collection.driver).supportsRelations && ((collection as any).relations)) {
-        const manyRelations = ((collection as any).relations)!.filter((r: Relation) => r.cardinality === "many");
+    if (getDataSourceCapabilities(collection.driver).supportsRelations) {
+        const resolvedRelations = resolveCollectionRelations(collection);
+        const manyRelations = Object.values(resolvedRelations).filter((r: Relation) => r.cardinality === "many");
+        
         return manyRelations.map((r: Relation) => {
             const target = r.target();
             if (!target) return undefined;
@@ -376,7 +379,7 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
 
             const targetWithOverrides = { ...target, ...baseOverrides };
             return (r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides) as EntityCollection<Record<string, unknown>>;
-        }).filter((c: any): c is EntityCollection<Record<string, unknown>> => Boolean(c));
+        }).filter((c: EntityCollection<Record<string, unknown>> | undefined): c is EntityCollection<Record<string, unknown>> => Boolean(c));
     }
 
     return [];