@rebasepro/server-postgresql 0.4.0 → 0.6.0

package/test/relations.test.ts

@@ -1113,3 +1113,250 @@ relationName: "recipient" }
         expect(namesInMessages[0]).not.toBe(namesInMessages[1]);
     });
 });
+
+describe("columnName vs property key deduplication regression", () => {
+    const extractRelationNames = (schema: string): string[] => {
+        const matches = schema.match(/relationName:\s*"([^"]+)"/g) ?? [];
+        return matches.map(m => m.replace(/relationName:\s*"/, "").replace(/"$/, ""));
+    };
+
+    it("should not emit a synthetic duplicate when property uses columnName different from property key", async () => {
+        // Scenario: engagements.clientId has columnName: "client_id"
+        // The explicit owning relation uses localKey: "clientId" (property key).
+        // The inverse relation on clients uses foreignKeyOnTarget: "client_id" (raw column).
+        // Without the fix, the synthetic loop would emit a broken second relation
+        // using engagements.client_id (which doesn't exist as a Drizzle property).
+        const clientsCollection: EntityCollection = {
+            slug: "clients",
+            table: "clients",
+            name: "Clients",
+            properties: {
+                id: { type: "string" },
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "engagements",
+                    target: () => engagementsCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "client_id"
+                }
+            ]
+        };
+
+        const engagementsCollection: EntityCollection = {
+            slug: "engagements",
+            table: "engagements",
+            name: "Engagements",
+            properties: {
+                id: { type: "string" },
+                clientId: {
+                    type: "relation",
+                    columnName: "client_id",
+                    target: () => clientsCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "clientId",
+                    relationName: "client"
+                } as any,
+                title: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "client",
+                    target: () => clientsCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "clientId"
+                }
+            ]
+        };
+
+        const result = await generateSchema([clientsCollection, engagementsCollection]);
+
+        // engagements should have exactly ONE one() entry for clientId
+        const engagementsRelBlock = result.match(/export const engagementsRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const oneEntries = (engagementsRelBlock.match(/:\s*one\(/g) ?? []).length;
+        expect(oneEntries).toBe(1);
+
+        // The one() entry must reference engagements.clientId (property key), NOT engagements.client_id
+        expect(engagementsRelBlock).toContain("engagements.clientId");
+        expect(engagementsRelBlock).not.toContain("engagements.client_id");
+
+        // No _synth_ entry should appear
+        expect(engagementsRelBlock).not.toContain("_synth_");
+    });
+
+    it("should produce matching relation names on both sides when columnName differs from property key", async () => {
+        const clientsCollection: EntityCollection = {
+            slug: "clients",
+            table: "clients",
+            name: "Clients",
+            properties: {
+                id: { type: "string" },
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "engagements",
+                    target: () => engagementsCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "client_id"
+                }
+            ]
+        };
+
+        const engagementsCollection: EntityCollection = {
+            slug: "engagements",
+            table: "engagements",
+            name: "Engagements",
+            properties: {
+                id: { type: "string" },
+                clientId: {
+                    type: "relation",
+                    columnName: "client_id",
+                    target: () => clientsCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "clientId",
+                    relationName: "client"
+                } as any,
+                title: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "client",
+                    target: () => clientsCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "clientId"
+                }
+            ]
+        };
+
+        const result = await generateSchema([clientsCollection, engagementsCollection]);
+
+        // Extract relation names from both sides
+        const engagementsRelBlock = result.match(/export const engagementsRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const clientsRelBlock = result.match(/export const clientsRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+
+        const engagementsRelNames = extractRelationNames(engagementsRelBlock);
+        const clientsRelNames = extractRelationNames(clientsRelBlock);
+
+        // Both sides must share the same relation name
+        expect(engagementsRelNames.length).toBeGreaterThanOrEqual(1);
+        expect(clientsRelNames.length).toBeGreaterThanOrEqual(1);
+
+        // The owning side's relation name should appear in the inverse side too
+        const sharedName = engagementsRelNames[0];
+        expect(clientsRelNames).toContain(sharedName);
+    });
+
+    it("should correctly handle inverse one-to-one with columnName on target", async () => {
+        // One-to-one: user has a profile, profile has userId with columnName: "user_id"
+        const usersCollection: EntityCollection = {
+            slug: "users",
+            table: "users",
+            name: "Users",
+            properties: {
+                id: { type: "string" },
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "profile",
+                    target: () => profilesCollection,
+                    cardinality: "one",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "user_id"
+                }
+            ]
+        };
+
+        const profilesCollection: EntityCollection = {
+            slug: "profiles",
+            table: "profiles",
+            name: "Profiles",
+            properties: {
+                id: { type: "string" },
+                userId: {
+                    type: "relation",
+                    columnName: "user_id",
+                    target: () => usersCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "userId",
+                    relationName: "user"
+                } as any,
+                bio: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "user",
+                    target: () => usersCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "userId"
+                }
+            ]
+        };
+
+        const result = await generateSchema([usersCollection, profilesCollection]);
+
+        // profiles should have exactly ONE one() entry
+        const profilesRelBlock = result.match(/export const profilesRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const oneEntries = (profilesRelBlock.match(/:\s*one\(/g) ?? []).length;
+        expect(oneEntries).toBe(1);
+
+        // Must reference profiles.userId (property key), NOT profiles.user_id
+        expect(profilesRelBlock).toContain("profiles.userId");
+        expect(profilesRelBlock).not.toContain("profiles.user_id");
+
+        // No _synth_ entry
+        expect(profilesRelBlock).not.toContain("_synth_");
+    });
+
+    it("should still emit synthetic relations when no explicit owning relation exists", async () => {
+        // When a collection has a FK column but no explicit owning relation defined,
+        // the synthetic loop should still create the missing relation.
+        const categoriesCollection: EntityCollection = {
+            slug: "categories",
+            table: "categories",
+            name: "Categories",
+            properties: {
+                id: { type: "string" },
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "products",
+                    target: () => productsCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "category_id"
+                }
+            ]
+        };
+
+        const productsCollection: EntityCollection = {
+            slug: "products",
+            table: "products",
+            name: "Products",
+            properties: {
+                id: { type: "string" },
+                name: { type: "string" },
+                category_id: { type: "string" }
+                // NOTE: no type: "relation" and no explicit relations[]
+            }
+        };
+
+        const result = await generateSchema([categoriesCollection, productsCollection]);
+
+        // products should get a synthetic one() for category_id
+        const productsRelBlock = result.match(/export const productsRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        expect(productsRelBlock).toContain("one(categories");
+        expect(productsRelBlock).toContain("products.category_id");
+    });
+});

package/test/unmapped-tables-safety.test.ts

@@ -49,7 +49,9 @@ function buildPrevSnapshot(tables: Record<string, any>, enums: Record<string, an
         roles: {},
         policies: {},
         views: {},
-        _meta: { schemas: {}, tables: {}, columns: {} }
+        _meta: { schemas: {},
+tables: {},
+columns: {} }
     };
 }
 
@@ -82,7 +84,9 @@ function snapshotColumn(name: string, type: string, opts: {
 }
 
 function snapshotEnum(name: string, schema: string, values: string[]) {
-    return { name, schema, values };
+    return { name,
+schema,
+values };
 }
 
 // ── Drizzle schema objects (the "managed" schema) ───────────────────────
@@ -106,7 +110,8 @@ describe("Unmapped tables safety", () => {
     describe("tablesFilter scoping", () => {
 
         it("should extract only managed table names from the tables export", () => {
-            const tables = { managedUsers, managedPosts };
+            const tables = { managedUsers,
+managedPosts };
             const tableNames = Object.values(tables).map(t => getTableName(t as Table));
 
             expect(tableNames).toEqual(["users", "posts"]);
@@ -115,7 +120,8 @@ describe("Unmapped tables safety", () => {
         });
 
         it("should produce a tablesFilter that excludes unmapped tables", () => {
-            const tables = { managedUsers, managedPosts };
+            const tables = { managedUsers,
+managedPosts };
             const tablesFilter = Object.values(tables).map(t => getTableName(t as Table));
 
             const unmappedTables = [
@@ -209,7 +215,8 @@ describe("Unmapped tables safety", () => {
                 })
             });
 
-            const curJson = generateDrizzleJson({ managedUsers, managedPosts });
+            const curJson = generateDrizzleJson({ managedUsers,
+managedPosts });
             const statements = await generateMigration(prevOnlyManaged as any, curJson as any);
 
             // No changes needed — managed schema is identical
@@ -276,7 +283,8 @@ describe("Unmapped tables safety", () => {
                 name: "Posts",
                 properties: {
                     title: { type: "string" },
-                    tags: { type: "relation", relationName: "tags" }
+                    tags: { type: "relation",
+relationName: "tags" }
                 },
                 relations: [{
                     relationName: "tags",

package/test/websocket.test.ts

@@ -61,7 +61,7 @@ describe("WebSocket Server SQL error handling", () => {
     it("should handle EXECUTE_SQL errors cleanly and return ERROR message without throwing", async () => {
         expect(mockWssInstance).toBeDefined();
         expect(mockWssInstance.on).toHaveBeenCalledWith("connection", expect.any(Function));
-        
+
         const connectionCallback = mockWssInstance.on.mock.calls.find(
             (call: any[]) => call[0] === "connection"
         )[1];

package/tsconfig.json

@@ -1,5 +1,7 @@
 {
   "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "rootDir": ".",
     "outDir": "dist",
     "module": "ESNEXT",
     "target": "ESNEXT",
@@ -35,6 +37,9 @@
       ],
       "@rebasepro/common": [
         "../common/src"
+      ],
+      "@rebasepro/server-core": [
+        "../server-core/src"
       ]
     }
   },

package/tsconfig.prod.json

@@ -1,6 +1,9 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "rootDir": "./src",
+    "paths": {},
     "noEmit": false,
     "declaration": true,
     "emitDeclarationOnly": true,

package/vite.config.ts

@@ -1,4 +1,3 @@
-// @ts-ignore
 import path from "path";
 
 import { defineConfig } from "vite";
@@ -10,8 +9,8 @@ const ReactCompilerConfig = {
 
 /**
  * Only externalize dependencies that the consumer app installs directly.
- * Everything else (transitive deps like jsonwebtoken, ws, zod, etc.)
- * gets inlined so linked consumers work without installing them.
+ * Everything else gets inlined so linked consumers work without installing them.
+ * The createRequire banner in output config provides require() for inlined CJS deps.
  */
 const CONSUMER_EXTERNALS = [
     "hono",
@@ -33,8 +32,8 @@ const isExternal = (id: string) => {
     // Externalize only deps the consumer app explicitly installs
     if (CONSUMER_EXTERNALS.some(ext => id === ext || id.startsWith(ext + "/"))) return true;
     // Externalize Node built-ins
-    if (["fs", "path", "url", "util", "crypto", "http", "https", "net", "tls", "stream", "events", "os", "child_process", "buffer", "assert", "dns", "zlib", "querystring", "node:"].some(b => id === b || id.startsWith("node:") || id.startsWith(b + "/"))) return true;
-    // Inline everything else (jsonwebtoken, ws, zod, etc.)
+    if (["fs", "path", "url", "util", "crypto", "http", "https", "net", "tls", "stream", "events", "os", "child_process", "buffer", "assert", "dns", "zlib", "querystring", "process", "module", "worker_threads", "v8", "vm", "string_decoder", "node:"].some(b => id === b || id.startsWith("node:") || id.startsWith(b + "/"))) return true;
+    // Inline everything else — createRequire banner handles require() for CJS deps
     return false;
 };
 
@@ -54,6 +53,7 @@ export default defineConfig(() => ({
         rollupOptions: {
             external: isExternal,
             output: {
+                banner: 'import { createRequire as __createRequire } from "module"; import process from "process"; const require = __createRequire(import.meta.url);',
                 globals: {
                     "json-logic-js": "jsonLogic",
                     "fast-equals": "fastEquals",

package/dist/common/src/collections/CollectionRegistry.d.ts

@@ -1,56 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-export declare class CollectionRegistry {
-    private collectionsByTableName;
-    private collectionsBySlug;
-    private rootCollections;
-    private cachedCollectionsList;
-    private rawCollectionsByTableName;
-    private rawCollectionsBySlug;
-    private rawRootCollections;
-    private cachedRawCollectionsList;
-    private lastRawInputSnapshot;
-    constructor(collections?: EntityCollection[]);
-    reset(): void;
-    /**
-     * Registers a collection and its subcollections recursively.
-     * Returns true if the collections have changed, false otherwise.
-     *
-     * Idempotent: compares the raw input (before normalization) against a stored
-     * snapshot. Only re-normalizes and re-registers when the raw input actually changed.
-     * @param collections
-     */
-    registerMultiple(collections: EntityCollection[]): boolean;
-    register(collection: EntityCollection, rawCollection?: EntityCollection): void;
-    private _registerRecursively;
-    normalizeCollection(collection: EntityCollection): EntityCollection;
-    /**
-     * Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
-     * This allows developers to define relations directly on properties without a separate
-     * `relations[]` entry on the collection.
-     */
-    private extractRelationsFromProperties;
-    private normalizeProperties;
-    private normalizeProperty;
-    get(path: string): EntityCollection | undefined;
-    /**
-     * Gets the pristine, un-normalized collection exactly as it was provided.
-     * Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
-     */
-    getRaw(path: string): EntityCollection | undefined;
-    /**
-     * Get collection by resolving multi-segment paths through relations
-     * e.g., "authors/70/posts" resolves to the posts collection
-     */
-    getCollectionByPath(collectionPath: string): EntityCollection | undefined;
-    getCollections(): EntityCollection[];
-    getRawCollections(): EntityCollection[];
-    /**
-     * Resolves a multi-segment path like "products/123/locales" and returns
-     * information about the collections and entity IDs along the path
-     */
-    resolvePathToCollections(path: string): {
-        collections: EntityCollection[];
-        entityIds: (string | number)[];
-        finalCollection: EntityCollection;
-    };
-}

package/dist/common/src/collections/default-collections.d.ts

@@ -1,9 +0,0 @@
-import type { PostgresCollection } from "@rebasepro/types";
-/**
- * Default users collection.
- *
- * Prepended to the developer's collections array by the admin and server.
- * Slug-based dedup (Map keyed by slug, last-write-wins) lets developers
- * override by defining their own collection with `slug: "users"`.
- */
-export declare const defaultUsersCollection: PostgresCollection;

package/dist/common/src/collections/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./CollectionRegistry";
-export * from "./default-collections";

package/dist/common/src/data/buildRebaseData.d.ts

@@ -1,14 +0,0 @@
-import { DataDriver, RebaseData } from "@rebasepro/types";
-/**
- * Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
- *
- * This is the key bridge: any property access like `data.products` returns
- * a `CollectionAccessor` backed by the underlying DataDriver, without
- * needing per-collection code generation.
- *
- * @example
- * const data = buildRebaseData(driver);
- * await data.products.create({ name: "Camera", price: 299 });
- * const { data: items } = await data.products.find({ where: { status: "eq.published" } });
- */
-export declare function buildRebaseData(driver: DataDriver): RebaseData;

package/dist/common/src/data/query_builder.d.ts

@@ -1,55 +0,0 @@
-import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
-export declare function or(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
-export declare function and(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
-export declare function cond(column: string, operator: FilterOperator, value: unknown): FilterCondition;
-export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
-    private collection;
-    private params;
-    constructor(collection: CollectionAccessor<M>);
-    /**
-     * Add a filter condition to your query.
-     * @example
-     * client.collection('users').where('age', '>=', 18).find()
-     */
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
-    where(logicalCondition: LogicalCondition): this;
-    /**
-     * Order the results by a specific column.
-     * @example
-     * client.collection('users').orderBy('createdAt', 'desc').find()
-     */
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
-    /**
-     * Limit the number of results returned.
-     */
-    limit(count: number): this;
-    /**
-     * Skip the first N results.
-     */
-    offset(count: number): this;
-    /**
-     * Set a free-text search string if supported by the backend.
-     */
-    search(searchString: string): 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;
-    /**
-     * Execute the find query and return the results.
-     */
-    find(): Promise<FindResponse<M>>;
-    /**
-     * Listen to realtime updates matching this query.
-     */
-    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
-}

package/dist/common/src/index.d.ts

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

package/dist/common/src/util/builders.d.ts

@@ -1,57 +0,0 @@
-import { AdditionalFieldDelegate, ArrayProperty, BooleanProperty, DateProperty, EntityCallbacks, EntityCollection, EnumValueConfig, EnumValues, GeopointProperty, MapProperty, NumberProperty, Properties, Property, ReferenceProperty, StringProperty, User } from "@rebasepro/types";
-/**
- * Identity function we use to defeat the type system of Typescript and build
- * collection views with all its properties
- * @param collection
- * @group Builder
- */
-export declare function buildCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): EntityCollection<M, USER>;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the property keys.
- * @param property
- * @group Builder
- */
-export declare function buildProperty<T, P extends Property = Property>(property: P): P extends StringProperty ? StringProperty : P extends NumberProperty ? NumberProperty : P extends BooleanProperty ? BooleanProperty : P extends DateProperty ? DateProperty : P extends GeopointProperty ? GeopointProperty : P extends ReferenceProperty ? ReferenceProperty : P extends ArrayProperty ? ArrayProperty : P extends MapProperty ? MapProperty : never;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param properties
- * @group Builder
- */
-export declare function buildProperties<M extends Record<string, unknown>>(properties: Properties): Properties;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param propertiesOrBuilder
- * @group Builder
- */
-export declare function buildPropertiesOrBuilder<M extends Record<string, unknown>>(propertiesOrBuilder: Properties): Properties;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param enumValues
- * @group Builder
- */
-export declare function buildEnum(enumValues: EnumValues): EnumValues;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param enumValueConfig
- * @group Builder
- */
-export declare function buildEnumValueConfig(enumValueConfig: EnumValueConfig): EnumValueConfig;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param callbacks
- * @group Builder
- */
-export declare function buildEntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>>(callbacks: EntityCallbacks<M>): EntityCallbacks<M>;
-/**
- * Identity function we use to defeat the type system of Typescript and build
- * additional field delegates views with all its properties
- * @param additionalFieldDelegate
- * @group Builder
- */
-export declare function buildAdditionalFieldDelegate<M extends Record<string, unknown>, USER extends User = User>(additionalFieldDelegate: AdditionalFieldDelegate<M, USER>): AdditionalFieldDelegate<M, USER>;

package/dist/common/src/util/callbacks.d.ts

@@ -1,6 +0,0 @@
-import { EntityCallbacks, Properties } from "@rebasepro/types";
-/**
- * Helper function to extract field-level PropertyCallbacks from a properties schema
- * and wrap them into an EntityCallbacks object recursively.
- */
-export declare const buildPropertyCallbacks: (properties: Properties) => EntityCallbacks | undefined;

package/dist/common/src/util/collections.d.ts

@@ -1,11 +0,0 @@
-import { DefaultSelectedViewBuilder, DefaultSelectedViewParams, EntityCollection, Properties } from "@rebasepro/types";
-export declare function sortProperties<M extends Record<string, unknown>>(properties: Properties, propertiesOrder?: string[]): Properties;
-export declare function resolveDefaultSelectedView(defaultSelectedView: string | DefaultSelectedViewBuilder | undefined, params: DefaultSelectedViewParams): string | undefined;
-export declare function getLocalChangesBackup(collection: EntityCollection): "manual_apply" | "auto_apply";
-/**
- * Returns the primary keys for an entity collection by inspecting the properties
- * and finding any properties with `isId`.
- * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
- * @param collection
- */
-export declare function getPrimaryKeys<M extends Record<string, unknown>>(collection: EntityCollection<M>): Extract<keyof M, string>[];

package/dist/common/src/util/common.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_ONE_OF_TYPE = "type";
-export declare const DEFAULT_ONE_OF_VALUE = "value";

package/dist/common/src/util/conditions.d.ts

@@ -1,26 +0,0 @@
-import { AuthController, ConditionContext, JsonLogicRule, Property } from "@rebasepro/types";
-/**
- * Register custom JSON Logic operations for Rebase.
- * Call this once at app initialization.
- */
-export declare function registerConditionOperations(): void;
-/**
- * Evaluate a JSON Logic rule against the given context.
- */
-export declare function evaluateCondition(rule: JsonLogicRule, context: ConditionContext): unknown;
-/**
- * Build a ConditionContext from the current property resolution context.
- */
-export declare function buildConditionContext(params: {
-    propertyKey?: string;
-    values?: Record<string, unknown>;
-    previousValues?: Record<string, unknown>;
-    path: string;
-    entityId?: string;
-    index?: number;
-    authController: AuthController;
-}): ConditionContext;
-/**
- * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
- */
-export declare function applyPropertyConditions(property: Property, context: ConditionContext): Property;