@api-client/core 0.20.1 → 0.20.3

package/tests/unit/modeling/RuntimeApiModel.spec.ts

@@ -10,11 +10,10 @@ test.group('RuntimeApiModel', () => {
   test('initializes from schema', ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const model = domain.addModel({ info: { name: 'Test Model' } })
-    const entity = model.addEntity({ key: 'ent-1', info: { name: 'User' } })
+    const entity = model.addEntity({ info: { name: 'User' } })
 
     const baseModel = new ApiModel(
       {
-        key: 'api-1',
         info: { name: 'Test API' },
       },
       domain
@@ -37,13 +36,15 @@ test.group('RuntimeApiModel', () => {
 
   test('resolves path with matchit', ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = domain.addModel({ info: { name: 'Test Model' } })
+    const entity = model.addEntity({ info: { name: 'User' } })
     const schema = {
       key: 'api-1',
       info: { name: 'Test API' },
       exposes: [
         {
           key: 'expose-1',
-          entity: { key: 'ent-1', type: 'association' },
+          entity: { key: entity.key, domain: domain.key },
           actions: [
             { kind: 'read', type: 'crud' },
             { kind: 'list', type: 'crud' },
@@ -92,7 +93,7 @@ test.group('RuntimeApiModel', () => {
     assert.isUndefined(getResult)
   }).tags(['@modeling', '@runtime'])
 
-  test('returns undefined when entity or action is missing', ({ assert }) => {
+  test('throws error when entity or action is missing', ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const schema = {
       key: 'api-1',
@@ -115,12 +116,14 @@ test.group('RuntimeApiModel', () => {
     const runtimeModel = new RuntimeApiModel(schema as any, domain.toJSON())
 
     // Exposed entity not found
-    const missingEntityResult = runtimeModel.lookupAction('GET', '/missing-entity')
-    assert.isUndefined(missingEntityResult)
+    assert.throws(() => {
+      runtimeModel.lookupAction('GET', '/missing-entity')
+    }, 'Missing exposure missing-expose')
 
     // Action not found on entity
-    const missingActionResult = runtimeModel.lookupAction('GET', '/missing-action')
-    assert.isUndefined(missingActionResult)
+    assert.throws(() => {
+      runtimeModel.lookupAction('GET', '/missing-action')
+    }, 'Missing action read')
   }).tags(['@modeling', '@runtime'])
 
   test('caches user entity and properties based on semantics', ({ assert }) => {
@@ -211,7 +214,7 @@ test.group('RuntimeApiModel', () => {
     assert.equal(runtimeModel.sessionProperties.size, 0)
   }).tags(['@modeling', '@runtime'])
 
-  test('evaluateAccess - rejects if any mandatory rule fails', async ({ assert }) => {
+  test('getEffectiveRules - separates mandatory and permission rules', async ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const baseModel = new ApiModel(
       { key: 'api-1', accessRule: [{ type: 'allowAuthenticated', mandatory: true }] },
@@ -220,40 +223,41 @@ test.group('RuntimeApiModel', () => {
     const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
 
     const mockAction = {
-      entity: { accessRule: [], parent: undefined },
+      exposure: { accessRule: [], parent: undefined },
       action: { kind: 'read', accessRule: [] },
     } as any
 
-    const evaluator: RuleEvaluator = async (_rule: AccessRule): Promise<boolean> => false // Mandatory rule fails
-    const result = await runtimeModel.evaluateAccess(mockAction, evaluator, AccessRuleExecutionPhase.PRE_FETCH)
-    assert.isFalse(result)
+    const rules = runtimeModel.getEffectiveRules(mockAction)
+    assert.equal(rules.preFetch.mandatoryRules.length, 1)
+    assert.equal(rules.preFetch.mandatoryRules[0].type, 'allowAuthenticated')
+    assert.equal(rules.preFetch.permissionRules.length, 0)
   }).tags(['@modeling', '@runtime', '@authorization'])
 
-  test('evaluateAccess - rejects by default if no rules hit', async ({ assert }) => {
+  test('getEffectiveRules - defaults to preFetch phase if none specified', async ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const baseModel = new ApiModel({ key: 'api-1' }, domain)
     const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
 
     const mockAction = {
-      entity: {
+      exposure: {
         accessRule: [{ type: 'allowPublic', metadata: { read: AccessRuleExecutionPhase.PRE_FETCH } }],
         parent: undefined,
       },
       action: { kind: 'read', accessRule: [] },
     } as any
 
-    const evaluator: RuleEvaluator = async (_rule: AccessRule): Promise<undefined> => undefined // No rules match
-    const result = await runtimeModel.evaluateAccess(mockAction, evaluator, AccessRuleExecutionPhase.PRE_FETCH)
-    assert.isFalse(result)
+    const rules = runtimeModel.getEffectiveRules(mockAction)
+    assert.equal(rules.preFetch.permissionRules.length, 1)
+    assert.equal(rules.preFetch.permissionRules[0].type, 'allowPublic')
   }).tags(['@modeling', '@runtime', '@authorization'])
 
-  test('evaluateAccess - evaluates from most specific to most general in permission phase', async ({ assert }) => {
+  test('getEffectiveRules - orders from most specific to most general', async ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
-    const baseModel = new ApiModel({ key: 'api-1', accessRule: [{ type: 'allowAuthenticated' }] }, domain)
+    const baseModel = new ApiModel({ accessRule: [{ type: 'allowAuthenticated' }] }, domain)
     const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
 
     const mockAction = {
-      entity: {
+      exposure: {
         accessRule: [{ type: 'allowPublic', metadata: { read: AccessRuleExecutionPhase.PRE_FETCH } }],
         parent: undefined,
       },
@@ -263,77 +267,19 @@ test.group('RuntimeApiModel', () => {
       },
     } as any
 
-    const evaluatedOrder: string[] = []
-    const evaluator: RuleEvaluator = async (rule: AccessRule): Promise<undefined> => {
-      evaluatedOrder.push(rule.type)
-      return undefined // Continue to next rule
-    }
-
-    await runtimeModel.evaluateAccess(mockAction, evaluator, AccessRuleExecutionPhase.PRE_FETCH)
-    assert.deepEqual(evaluatedOrder, ['matchEmailDomain', 'allowPublic', 'allowAuthenticated'])
-  }).tags(['@modeling', '@runtime', '@authorization'])
-
-  test('evaluateAccess - short-circuits on explicit allow or deny in permission phase', async ({ assert }) => {
-    const domain = new DataDomain({ info: { version: '1.0.0' } })
-    const baseModel = new ApiModel({ key: 'api-1', accessRule: [{ type: 'allowAuthenticated' }] }, domain)
-    const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
-
-    const mockAction = {
-      entity: {
-        accessRule: [{ type: 'allowPublic', metadata: { read: AccessRuleExecutionPhase.PRE_FETCH } }],
-        parent: undefined,
-      },
-      action: {
-        kind: 'read',
-        accessRule: [{ type: 'matchEmailDomain', metadata: { read: AccessRuleExecutionPhase.PRE_FETCH } }],
-      },
-    } as any
-
-    const evaluatedOrder: string[] = []
-    const evaluator = async (rule: any) => {
-      evaluatedOrder.push(rule.type)
-      if (rule.type === 'allowPublic') return true
-      return undefined
-    }
-
-    const result = await runtimeModel.evaluateAccess(mockAction, evaluator, AccessRuleExecutionPhase.PRE_FETCH)
-    assert.isTrue(result)
-    // Should not reach the api-rule
-    assert.deepEqual(evaluatedOrder, ['matchEmailDomain', 'allowPublic'])
-  }).tags(['@modeling', '@runtime', '@authorization'])
-
-  test('evaluateAccess - passes mandatory phase and uses permission phase result', async ({ assert }) => {
-    const domain = new DataDomain({ info: { version: '1.0.0' } })
-    const baseModel = new ApiModel(
-      { key: 'api-1', accessRule: [{ type: 'allowAuthenticated', mandatory: true }] },
-      domain
+    const rules = runtimeModel.getEffectiveRules(mockAction)
+    assert.equal(rules.preFetch.permissionRules.length, 3)
+    assert.deepEqual(
+      rules.preFetch.permissionRules.map((r) => r.type),
+      ['matchEmailDomain', 'allowPublic', 'allowAuthenticated']
     )
-    const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
-
-    const mockAction = {
-      entity: {
-        accessRule: [{ type: 'allowPublic', metadata: { read: AccessRuleExecutionPhase.PRE_FETCH } }],
-        parent: undefined,
-      },
-      action: { kind: 'read', accessRule: [] },
-    } as any
-
-    const evaluator = async (rule: any) => {
-      if (rule.mandatory) return true // passes mandatory check
-      if (rule.type === 'allowPublic') return false // explicitly denies
-      return undefined
-    }
-
-    const result = await runtimeModel.evaluateAccess(mockAction, evaluator, AccessRuleExecutionPhase.PRE_FETCH)
-    assert.isFalse(result) // Denied by permission rule
   }).tags(['@modeling', '@runtime', '@authorization'])
 
-  test('evaluateAccess - shadows parent rules of the same type', async ({ assert }) => {
+  test('getEffectiveRules - shadows parent rules of the same type', async ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const model = domain.addModel({ key: 'mod-1' })
     const entity = model.addEntity({ key: 'ent-1' })
 
-    // Create base model with exposing and actions directly in schema
     const baseModel = new ApiModel(
       {
         key: 'api-1',
@@ -361,19 +307,6 @@ test.group('RuntimeApiModel', () => {
       domain
     )
 
-    // Hierarchy will be:
-    // Action: allowAuthenticated (mandatory)
-    // Entity: allowPublic, matchEmailDomain (mandatory)
-    // API: allowAuthenticated, matchEmailDomain
-
-    // Effective Rules (with shadowing):
-    // Action's allowAuthenticated (mandatory) shadows API's allowAuthenticated
-    // Entity's matchEmailDomain (mandatory) shadows API's matchEmailDomain
-    // Entity's allowPublic is kept
-
-    // Mandatory: allowAuthenticated, matchEmailDomain
-    // Permission: allowPublic
-
     const schema: RuntimeApiModelSchema = {
       ...baseModel.toJSON(),
       routingMap: {
@@ -384,16 +317,15 @@ test.group('RuntimeApiModel', () => {
     const runtimeModel = new RuntimeApiModel(schema, domain.toJSON())
     const mockAction = runtimeModel.lookupAction('GET', '/test')!
 
-    const evaluatedOrder: string[] = []
-    const evaluator: RuleEvaluator = async (rule: AccessRule): Promise<boolean | undefined> => {
-      evaluatedOrder.push(`${rule.type}${rule.mandatory ? '-mandatory' : ''}`)
-      if (rule.mandatory) return true
-      return undefined
-    }
-
-    await runtimeModel.evaluateAccess(mockAction, evaluator, AccessRuleExecutionPhase.PRE_FETCH)
+    const rules = runtimeModel.getEffectiveRules(mockAction)
 
-    // Check that we only evaluate the shadowed rules, exactly once per phase
-    assert.deepEqual(evaluatedOrder, ['allowAuthenticated-mandatory', 'matchEmailDomain-mandatory', 'allowPublic'])
+    assert.deepEqual(
+      rules.preFetch.mandatoryRules.map((r) => r.type),
+      ['allowAuthenticated', 'matchEmailDomain']
+    )
+    assert.deepEqual(
+      rules.preFetch.permissionRules.map((r) => r.type),
+      ['allowPublic']
+    )
   }).tags(['@modeling', '@runtime', '@authorization'])
 })

package/tests/unit/modeling/client_ip_address_semantic.spec.ts

@@ -5,8 +5,6 @@ import {
   isPropertySemantic,
   SemanticCategory,
   SemanticScope,
-  SemanticTiming,
-  SemanticOperation,
 } from '../../../src/modeling/Semantics.js'
 
 test.group('ClientIPAddress Semantic', () => {
@@ -48,24 +46,4 @@ test.group('ClientIPAddress Semantic', () => {
     const semantic = DataSemantics[SemanticType.ClientIPAddress]
     assert.isFalse(semantic.hasConfig)
   })
-
-  test('should have correct runtime configuration', ({ assert }) => {
-    const semantic = DataSemantics[SemanticType.ClientIPAddress]
-    const runtime = semantic.runtime
-
-    assert.equal(runtime.timing, SemanticTiming.Before)
-    assert.deepEqual(runtime.operations, [SemanticOperation.Create, SemanticOperation.Update])
-    assert.equal(runtime.priority, 95) // Low priority, populate after other validations
-    assert.equal(runtime.timeoutMs, 100) // Very fast operation
-  })
-
-  test('should have correct execution conditions', ({ assert }) => {
-    const semantic = DataSemantics[SemanticType.ClientIPAddress]
-    const conditions = semantic.runtime.conditions
-
-    assert.isDefined(conditions)
-    assert.lengthOf(conditions!, 1)
-    assert.equal(conditions![0].expression, 'entity[semantics.ClientIPAddress] == null')
-    assert.equal(conditions![0].description, 'Only set IP address if not already provided')
-  })
 })

package/tests/unit/modeling/semantics.spec.ts

@@ -3,8 +3,6 @@ import {
   SemanticType,
   SemanticScope,
   SemanticCategory,
-  SemanticTiming,
-  SemanticOperation,
   isEntitySemantic,
   isPropertySemantic,
   isAssociationSemantic,
@@ -52,10 +50,6 @@ test.group('Semantics', () => {
       scope: SemanticScope.Entity,
       category: SemanticCategory.Identity,
       hasConfig: false,
-      runtime: {
-        timing: SemanticTiming.None,
-        operations: [],
-      },
     }
     const propertySemantic: PropertySemantic = {
       id: SemanticType.CreatedTimestamp,
@@ -65,11 +59,6 @@ test.group('Semantics', () => {
       category: SemanticCategory.Lifecycle,
       hasConfig: false,
       applicableDataTypes: ['datetime'],
-      runtime: {
-        timing: SemanticTiming.Before,
-        operations: [SemanticOperation.Create],
-        priority: 90,
-      },
     }
     const associationSemantic: AssociationSemantic = {
       id: SemanticType.ResourceOwnerIdentifier,
@@ -78,18 +67,6 @@ test.group('Semantics', () => {
       scope: SemanticScope.Association,
       category: SemanticCategory.Identity,
       hasConfig: false,
-      runtime: {
-        timing: SemanticTiming.Before,
-        operations: [
-          SemanticOperation.Create,
-          SemanticOperation.Read,
-          SemanticOperation.Update,
-          SemanticOperation.Delete,
-          SemanticOperation.List,
-        ],
-        priority: 5,
-        canDisable: false,
-      },
     }
 
     assert.isTrue(isEntitySemantic(entitySemantic))
@@ -105,10 +82,6 @@ test.group('Semantics', () => {
       scope: SemanticScope.Entity,
       category: SemanticCategory.Identity,
       hasConfig: false,
-      runtime: {
-        timing: SemanticTiming.None,
-        operations: [],
-      },
     }
     const propertySemantic: PropertySemantic = {
       id: SemanticType.CreatedTimestamp,
@@ -118,11 +91,6 @@ test.group('Semantics', () => {
       category: SemanticCategory.Lifecycle,
       hasConfig: false,
       applicableDataTypes: ['datetime'],
-      runtime: {
-        timing: SemanticTiming.Before,
-        operations: [SemanticOperation.Create],
-        priority: 90,
-      },
     }
     const associationSemantic: AssociationSemantic = {
       id: SemanticType.ResourceOwnerIdentifier,
@@ -131,18 +99,6 @@ test.group('Semantics', () => {
       scope: SemanticScope.Association,
       category: SemanticCategory.Identity,
       hasConfig: false,
-      runtime: {
-        timing: SemanticTiming.Before,
-        operations: [
-          SemanticOperation.Create,
-          SemanticOperation.Read,
-          SemanticOperation.Update,
-          SemanticOperation.Delete,
-          SemanticOperation.List,
-        ],
-        priority: 5,
-        canDisable: false,
-      },
     }
 
     assert.isFalse(isPropertySemantic(entitySemantic))
@@ -158,10 +114,6 @@ test.group('Semantics', () => {
       scope: SemanticScope.Entity,
       category: SemanticCategory.Identity,
       hasConfig: false,
-      runtime: {
-        timing: SemanticTiming.None,
-        operations: [],
-      },
     }
     const propertySemantic: PropertySemantic = {
       id: SemanticType.CreatedTimestamp,
@@ -171,11 +123,6 @@ test.group('Semantics', () => {
       category: SemanticCategory.Lifecycle,
       hasConfig: false,
       applicableDataTypes: ['datetime'],
-      runtime: {
-        timing: SemanticTiming.Before,
-        operations: [SemanticOperation.Create],
-        priority: 90,
-      },
     }
     const associationSemantic: AssociationSemantic = {
       id: SemanticType.ResourceOwnerIdentifier,
@@ -184,18 +131,6 @@ test.group('Semantics', () => {
       scope: SemanticScope.Association,
       category: SemanticCategory.Identity,
       hasConfig: false,
-      runtime: {
-        timing: SemanticTiming.Before,
-        operations: [
-          SemanticOperation.Create,
-          SemanticOperation.Read,
-          SemanticOperation.Update,
-          SemanticOperation.Delete,
-          SemanticOperation.List,
-        ],
-        priority: 5,
-        canDisable: false,
-      },
     }
 
     assert.isFalse(isAssociationSemantic(entitySemantic))

package/tests/unit/modeling/username_semantic.spec.ts

@@ -5,8 +5,6 @@ import {
   isPropertySemantic,
   SemanticCategory,
   SemanticScope,
-  SemanticTiming,
-  SemanticOperation,
 } from '../../../src/modeling/Semantics.js'
 
 test.group('Username Semantic', () => {
@@ -48,34 +46,4 @@ test.group('Username Semantic', () => {
     const semantic = DataSemantics[SemanticType.Username]
     assert.isFalse(semantic.hasConfig)
   })
-
-  test('should not be disableable for security reasons', ({ assert }) => {
-    const semantic = DataSemantics[SemanticType.Username]
-    assert.isFalse(semantic.runtime.canDisable)
-  })
-
-  test('should have correct runtime configuration', ({ assert }) => {
-    const semantic = DataSemantics[SemanticType.Username]
-    const runtime = semantic.runtime
-
-    assert.equal(runtime.timing, SemanticTiming.Before)
-    assert.deepEqual(runtime.operations, [SemanticOperation.Create, SemanticOperation.Update, SemanticOperation.Read])
-    assert.equal(runtime.priority, 15) // High priority for authentication
-    assert.equal(runtime.timeoutMs, 100) // Fast operation
-  })
-
-  test('should have higher priority than general user properties but lower than password', ({ assert }) => {
-    const usernameSemantic = DataSemantics[SemanticType.Username]
-    const passwordSemantic = DataSemantics[SemanticType.Password]
-    const userRoleSemantic = DataSemantics[SemanticType.UserRole]
-
-    const usernameP = usernameSemantic.runtime.priority ?? 100
-    const passwordP = passwordSemantic.runtime.priority ?? 100
-    const userRoleP = userRoleSemantic.runtime.priority ?? 100
-
-    // Username should have lower priority number (higher priority) than UserRole
-    assert.isAtMost(usernameP, userRoleP)
-    // But higher priority number (lower priority) than Password
-    assert.isAtLeast(usernameP, passwordP)
-  })
 })

package/build/src/runtime/modeling/Semantics.d.ts

@@ -1,84 +0,0 @@
-import { Jexl } from '@pawel-up/jexl/Jexl.js';
-import type { DomainEntity } from '../../modeling/DomainEntity.js';
-import { type AppliedDataSemantic, type SemanticCondition, SemanticOperation, SemanticType } from '../../modeling/Semantics.js';
-import type { TransformFunction } from '@pawel-up/jexl';
-/**
- * Get or create a JEXL instance with optional custom transforms
- */
-export declare function getJexlInstance(transforms?: Record<string, TransformFunction>): Jexl;
-/**
- * Context object passed to semantic condition evaluation
- */
-export interface SemanticExecutionContext {
-    /**
-     * The entity data being processed
-     */
-    entity: Record<string, unknown>;
-    /**
-     * Current user context (if authenticated)
-     */
-    user?: {
-        id?: string;
-        authenticated?: boolean;
-        roles?: string[];
-        [key: string]: unknown;
-    };
-    /**
-     * The current database operation
-     */
-    operation: SemanticOperation;
-    /**
-     * Applied semantics with their field mappings
-     */
-    appliedSemantics: AppliedDataSemantic[];
-    /**
-     * Configuration for the current semantic being evaluated
-     */
-    config?: Record<string, unknown>;
-}
-/**
- * Builds a semantics object for JEXL evaluation that maps semantic types to actual field names.
- *
- * The resulting map should be used in JEXL expressions to reference semantic fields.
- *
- * @returns A map where keys are semantic type identifiers and values are the field names.
- *
- * @example
- * const semanticFieldMap = buildSemanticFieldMap(entity);
- * const result = await jexl.eval("semantics.CreatedTimestamp == null", {
- *  semantics: semanticFieldMap,
- *  ...
- * }
- */
-export declare function buildSemanticFieldMap(entity: DomainEntity): Record<string, string>;
-/**
- * Evaluates a semantic condition against the execution context
- * In a real implementation, this would use JEXL to evaluate the expression
- *
- * @param condition The semantic condition to evaluate
- * @param context The execution context containing entity data, user info, etc.
- * @param semanticFieldMap A map of semantic field names to their actual field names.
- *                         Use the `buildSemanticFieldMap()` function to create this map.
- * @param jexl Optional JEXL instance to use for evaluation, defaults to a cached instance.
- * @returns A promise that resolves to true if the condition is met, false otherwise
- */
-export declare function evaluateSemanticCondition(condition: SemanticCondition, context: SemanticExecutionContext, semanticFieldMap: Record<string, string>, jexl?: Jexl): Promise<boolean>;
-/**
- * Check if semantic should execute based on all its conditions
- *
- * @param semantic The semantic to check
- * @param context The execution context containing entity data, user info, etc.
- * @param semanticFieldMap A map of semantic field names to their actual field names.
- *                         Use the `buildSemanticFieldMap()` function to create this map.
- * @return A promise that resolves to true if all conditions are met, false otherwise
- */
-export declare function shouldSemanticExecute(semantic: AppliedDataSemantic, context: SemanticExecutionContext, semanticFieldMap: Record<string, string>): Promise<boolean>;
-/**
- * Helper to get the actual field name for a semantic type
- */
-export declare function getFieldNameForSemantic(semanticType: SemanticType, semanticFieldMap: Record<string, string>): string | undefined;
-/**
- * Validates that all semantic references in conditions are available
- */
-export declare function validateSemanticConditions(semantic: AppliedDataSemantic, semanticFieldMap: Record<string, string>): string[];
-//# sourceMappingURL=Semantics.d.ts.map

package/build/src/runtime/modeling/Semantics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Semantics.d.ts","sourceRoot":"","sources":["../../../../src/runtime/modeling/Semantics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAClE,OAAO,EACL,KAAK,mBAAmB,EAExB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,YAAY,EACb,MAAM,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAOvD;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,CAcpF;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B;;OAEG;IACH,IAAI,CAAC,EAAE;QACL,EAAE,CAAC,EAAE,MAAM,CAAA;QACX,aAAa,CAAC,EAAE,OAAO,CAAA;QACvB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;QAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAA;IACD;;OAEG;IACH,SAAS,EAAE,iBAAiB,CAAA;IAC5B;;OAEG;IACH,gBAAgB,EAAE,mBAAmB,EAAE,CAAA;IACvC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACjC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBlF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,iBAAiB,EAC5B,OAAO,EAAE,wBAAwB,EACjC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,IAAI,GAAE,IAAwB,GAC7B,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,wBAAwB,EACjC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,OAAO,CAAC,OAAO,CAAC,CAalB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,YAAY,EAC1B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,GAAG,SAAS,CAGpB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,mBAAmB,EAC7B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,EAAE,CAuBV"}

package/build/src/runtime/modeling/Semantics.js

@@ -1,124 +0,0 @@
-import { Jexl } from '@pawel-up/jexl/Jexl.js';
-import { DataSemantics, } from '../../modeling/Semantics.js';
-/**
- * Cache for JEXL instances to avoid recreation overhead
- */
-const jexlCache = new Map();
-/**
- * Get or create a JEXL instance with optional custom transforms
- */
-export function getJexlInstance(transforms) {
-    const cacheKey = transforms ? JSON.stringify(Object.keys(transforms).sort()) : 'default';
-    if (!jexlCache.has(cacheKey)) {
-        const jexl = new Jexl();
-        if (transforms) {
-            Object.entries(transforms).forEach(([name, fn]) => {
-                jexl.addTransform(name, fn);
-            });
-        }
-        jexlCache.set(cacheKey, jexl);
-    }
-    return jexlCache.get(cacheKey);
-}
-/**
- * Builds a semantics object for JEXL evaluation that maps semantic types to actual field names.
- *
- * The resulting map should be used in JEXL expressions to reference semantic fields.
- *
- * @returns A map where keys are semantic type identifiers and values are the field names.
- *
- * @example
- * const semanticFieldMap = buildSemanticFieldMap(entity);
- * const result = await jexl.eval("semantics.CreatedTimestamp == null", {
- *  semantics: semanticFieldMap,
- *  ...
- * }
- */
-export function buildSemanticFieldMap(entity) {
-    const semanticFieldMap = {};
-    for (const property of entity.properties) {
-        if (!property.info.name) {
-            continue; // Skip properties without a name
-        }
-        for (const semantic of property.semantics) {
-            // We use the truncated `semantic.id` as the key, e.g. 'Password' so that it is possible to do something like:
-            // `entity[semantics.Password] != null && !entity[semantics.Password].startsWith('$')`
-            // Where the `semantics` object is the object returned by this function and
-            // passed to the JEXL context.
-            const semanticKey = semantic.id.replace('Semantic#', '');
-            semanticFieldMap[semanticKey] = property.info.name;
-        }
-    }
-    return semanticFieldMap;
-}
-/**
- * Evaluates a semantic condition against the execution context
- * In a real implementation, this would use JEXL to evaluate the expression
- *
- * @param condition The semantic condition to evaluate
- * @param context The execution context containing entity data, user info, etc.
- * @param semanticFieldMap A map of semantic field names to their actual field names.
- *                         Use the `buildSemanticFieldMap()` function to create this map.
- * @param jexl Optional JEXL instance to use for evaluation, defaults to a cached instance.
- * @returns A promise that resolves to true if the condition is met, false otherwise
- */
-export function evaluateSemanticCondition(condition, context, semanticFieldMap, jexl = getJexlInstance()) {
-    // Build the evaluation context
-    const evalContext = {
-        entity: context.entity,
-        user: context.user,
-        operation: context.operation,
-        config: context.config,
-        semantics: semanticFieldMap,
-    };
-    return jexl.eval(condition.expression, evalContext);
-}
-/**
- * Check if semantic should execute based on all its conditions
- *
- * @param semantic The semantic to check
- * @param context The execution context containing entity data, user info, etc.
- * @param semanticFieldMap A map of semantic field names to their actual field names.
- *                         Use the `buildSemanticFieldMap()` function to create this map.
- * @return A promise that resolves to true if all conditions are met, false otherwise
- */
-export async function shouldSemanticExecute(semantic, context, semanticFieldMap) {
-    const definition = DataSemantics[semantic.id];
-    const conditions = definition?.runtime?.conditions;
-    if (!conditions || conditions.length === 0) {
-        return true;
-    }
-    const results = await Promise.all(conditions.map((condition) => evaluateSemanticCondition(condition, context, semanticFieldMap)));
-    // All conditions must evaluate to true
-    return results.every((result) => result === true);
-}
-/**
- * Helper to get the actual field name for a semantic type
- */
-export function getFieldNameForSemantic(semanticType, semanticFieldMap) {
-    const semanticKey = semanticType.replace('Semantic#', '');
-    return semanticFieldMap[semanticKey];
-}
-/**
- * Validates that all semantic references in conditions are available
- */
-export function validateSemanticConditions(semantic, semanticFieldMap) {
-    const definition = DataSemantics[semantic.id];
-    const conditions = definition?.runtime?.conditions || [];
-    const errors = [];
-    conditions.forEach((condition, index) => {
-        // Extract semantic references from the condition expression
-        // Look for patterns like "semantics.CreatedTimestamp" or "entity[semantics.Password]"
-        const semanticMatches = condition.expression.match(/semantics\.(\w+)/g);
-        if (semanticMatches) {
-            semanticMatches.forEach((match) => {
-                const semanticKey = match.replace('semantics.', '');
-                if (!semanticFieldMap[semanticKey]) {
-                    errors.push(`Condition ${index + 1} references semantic "${semanticKey}" but no field with that semantic was found`);
-                }
-            });
-        }
-    });
-    return errors;
-}
-//# sourceMappingURL=Semantics.js.map