@api-client/core 0.19.4 → 0.19.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/ai/DataDomainDelta.ts

@@ -119,7 +119,7 @@ export class DataDomainDelta {
 
     if (delta.addedEntities) {
       for (const e of delta.addedEntities) {
-        this.handleAddEntity(this.domain, e)
+        this.handleAddEntity(e)
       }
     }
 
@@ -150,6 +150,9 @@ export class DataDomainDelta {
         if (mod.name) entity.info.name = mod.name
         if (mod.displayName) entity.info.displayName = mod.displayName
         if (mod.description) entity.info.description = mod.description
+        if (mod.tags !== undefined) {
+          entity.tags = mod.tags === null ? [] : mod.tags
+        }
 
         this.applySemantics(entity, mod.addedSemantics, mod.modifiedSemantics, mod.deletedSemanticIds)
 
@@ -181,8 +184,8 @@ export class DataDomainDelta {
    * @param domain The data domain where the entity will reside.
    * @param e The schema definition of the entity to be added.
    */
-  protected handleAddEntity(domain: DataDomain, e: AiDomainEntityResponseSchema): void {
-    const targetModel = this.getModel(domain, e.modelKey || 'ai_generated')
+  protected handleAddEntity(e: AiDomainEntityResponseSchema): void {
+    const targetModel = this.getModel(this.domain, e.modelKey || 'ai_generated')
     const entityInput = { ...e }
     delete entityInput.semantics
     let entityKey = this.keyMap.get(e.key)
@@ -261,7 +264,7 @@ export class DataDomainDelta {
       writeOnly: p.constraints?.writeOnly,
       deprecated: p.deprecated,
       schema: p.schema,
-      tags: p.tags,
+      tags: p.tags || undefined,
     })
     this.applySemantics(prop, p.semantics)
   }
@@ -273,7 +276,7 @@ export class DataDomainDelta {
    * @param domain The target data domain.
    * @param keys The array of property keys (AI-generated or actual) to remove.
    */
-  handlePropertyDeletes(domain: DataDomain, keys?: string[]): void {
+  protected handlePropertyDeletes(domain: DataDomain, keys?: string[]): void {
     if (!keys) {
       return
     }
@@ -294,7 +297,7 @@ export class DataDomainDelta {
    * @param domain The target data domain.
    * @param mods The list of property modifications to apply.
    */
-  handlePropertyMods(domain: DataDomain, mods?: AiDomainPropertyDelta[]): void {
+  protected handlePropertyMods(domain: DataDomain, mods?: AiDomainPropertyDelta[]): void {
     if (!mods) {
       return
     }
@@ -317,72 +320,76 @@ export class DataDomainDelta {
         prop.type = mod.type
       }
       if (mod.deprecated !== undefined) {
-        prop.deprecated = mod.deprecated
+        prop.deprecated = mod.deprecated === null ? undefined : mod.deprecated
       }
       if (mod.constraints) {
         if (mod.constraints.required !== undefined) {
-          prop.required = mod.constraints.required
+          prop.required = mod.constraints.required === null ? undefined : mod.constraints.required
         }
         if (mod.constraints.unique !== undefined) {
-          prop.unique = mod.constraints.unique
+          prop.unique = mod.constraints.unique === null ? undefined : mod.constraints.unique
         }
         if (mod.constraints.index !== undefined) {
-          prop.index = mod.constraints.index
+          prop.index = mod.constraints.index === null ? undefined : mod.constraints.index
         }
         if (mod.constraints.primary !== undefined) {
-          prop.primary = mod.constraints.primary
+          prop.primary = mod.constraints.primary === null ? undefined : mod.constraints.primary
         }
         if (mod.constraints.multiple !== undefined) {
-          prop.multiple = mod.constraints.multiple
+          prop.multiple = mod.constraints.multiple === null ? undefined : mod.constraints.multiple
         }
         if (mod.constraints.readOnly !== undefined) {
-          prop.readOnly = mod.constraints.readOnly
+          prop.readOnly = mod.constraints.readOnly === null ? undefined : mod.constraints.readOnly
         }
         if (mod.constraints.writeOnly !== undefined) {
-          prop.writeOnly = mod.constraints.writeOnly
+          prop.writeOnly = mod.constraints.writeOnly === null ? undefined : mod.constraints.writeOnly
         }
       }
       if (mod.schema) {
         if (!prop.schema) {
           prop.schema = {}
         }
-        if (mod.schema.defaultValue) {
-          if (!prop.schema.defaultValue) {
-            prop.schema.defaultValue = {
-              value: '',
-              type: 'literal',
+        if (mod.schema.defaultValue !== undefined) {
+          if (mod.schema.defaultValue === null) {
+            prop.schema.defaultValue = undefined
+          } else {
+            if (!prop.schema.defaultValue) {
+              prop.schema.defaultValue = {
+                value: '',
+                type: 'literal',
+              }
+            }
+            if (mod.schema.defaultValue.type) {
+              prop.schema.defaultValue.type = mod.schema.defaultValue.type
+            }
+            if (mod.schema.defaultValue.value) {
+              prop.schema.defaultValue.value = mod.schema.defaultValue.value
             }
-          }
-          if (mod.schema.defaultValue.type) {
-            prop.schema.defaultValue.type = mod.schema.defaultValue.type
-          }
-          if (mod.schema.defaultValue.value) {
-            prop.schema.defaultValue.value = mod.schema.defaultValue.value
           }
         }
         if (mod.schema.pattern !== undefined) {
-          prop.schema.pattern = mod.schema.pattern
+          prop.schema.pattern = mod.schema.pattern === null ? undefined : mod.schema.pattern
         }
         if (mod.schema.minimum !== undefined) {
-          prop.schema.minimum = mod.schema.minimum
+          prop.schema.minimum = mod.schema.minimum === null ? undefined : mod.schema.minimum
         }
         if (mod.schema.maximum !== undefined) {
-          prop.schema.maximum = mod.schema.maximum
+          prop.schema.maximum = mod.schema.maximum === null ? undefined : mod.schema.maximum
         }
         if (mod.schema.exclusiveMinimum !== undefined) {
-          prop.schema.exclusiveMinimum = mod.schema.exclusiveMinimum
+          prop.schema.exclusiveMinimum = mod.schema.exclusiveMinimum === null ? undefined : mod.schema.exclusiveMinimum
         }
         if (mod.schema.exclusiveMaximum !== undefined) {
-          prop.schema.exclusiveMaximum = mod.schema.exclusiveMaximum
+          prop.schema.exclusiveMaximum = mod.schema.exclusiveMaximum === null ? undefined : mod.schema.exclusiveMaximum
         }
         if (mod.schema.multipleOf !== undefined) {
-          prop.schema.multipleOf = mod.schema.multipleOf
+          prop.schema.multipleOf = mod.schema.multipleOf === null ? undefined : mod.schema.multipleOf
         }
         if (mod.schema.enum !== undefined) {
-          prop.schema.enum = [...mod.schema.enum]
+          prop.schema.enum = mod.schema.enum === null ? undefined : [...mod.schema.enum]
         }
         if (mod.schema.examples !== undefined) {
-          prop.schema.examples = [...mod.schema.examples]
+          prop.schema.examples = mod.schema.examples === null ? undefined : [...mod.schema.examples]
         }
       }
       this.applySemantics(prop, mod.addedSemantics, mod.modifiedSemantics, mod.deletedSemanticIds)
@@ -395,7 +402,7 @@ export class DataDomainDelta {
    * @param entity The target domain entity referencing the newly created associations.
    * @param adds An array of association definitions to add, if any.
    */
-  handleAssociationAdds(entity: DomainEntity, adds: AiDomainAssociation[] | undefined): void {
+  protected handleAssociationAdds(entity: DomainEntity, adds: AiDomainAssociation[] | undefined): void {
     if (!adds) {
       return
     }
@@ -412,7 +419,7 @@ export class DataDomainDelta {
    * @param entity The source domain entity creating the association.
    * @param a The defining schema for the new association.
    */
-  handleAddAssociation(entity: DomainEntity, a: AiDomainAssociation): void {
+  protected handleAddAssociation(entity: DomainEntity, a: AiDomainAssociation): void {
     let assocKey = this.keyMap.get(a.key)
     if (!assocKey) {
       assocKey = nanoid()
@@ -467,7 +474,7 @@ export class DataDomainDelta {
    * @param domain The target data domain.
    * @param keys An array of association keys to safely remove.
    */
-  handleAssociationDeletes(domain: DataDomain, keys?: string[]): void {
+  protected handleAssociationDeletes(domain: DataDomain, keys?: string[]): void {
     if (!keys) {
       return
     }
@@ -488,7 +495,7 @@ export class DataDomainDelta {
    * @param domain The target data domain containing the associations.
    * @param mods An array of requested association modifications.
    */
-  handleAssociationMods(domain: DataDomain, mods: AiDomainAssociationDelta[] | undefined): void {
+  protected handleAssociationMods(domain: DataDomain, mods: AiDomainAssociationDelta[] | undefined): void {
     if (!mods) {
       return
     }
@@ -508,10 +515,13 @@ export class DataDomainDelta {
         assoc.info.description = mod.description
       }
       if (mod.required !== undefined) {
-        assoc.required = mod.required
+        assoc.required = mod.required === null ? undefined : mod.required
+      }
+      if (mod.multiple !== undefined) {
+        assoc.multiple = mod.multiple === null ? undefined : mod.multiple
       }
       if (mod.onDelete !== undefined) {
-        assoc.onDelete = mod.onDelete
+        assoc.onDelete = mod.onDelete === null ? undefined : mod.onDelete
       }
 
       if (mod.targets) {

package/src/modeling/ai/domain_response_schema.ts

@@ -9,6 +9,18 @@ const SemanticSchema = {
   required: ['id'],
 }
 
+const AssociationTarget = {
+  type: Type.OBJECT,
+  properties: {
+    key: { type: Type.STRING, description: 'The key of the target entity.' },
+    domain: {
+      type: Type.STRING,
+      description: 'The key of the target data domain. Only set when the target is in a different data domain.',
+    },
+  },
+  required: ['key'],
+}
+
 const SchemaDefaultValue = {
   type: Type.OBJECT,
   properties: {
@@ -27,28 +39,28 @@ const SchemaDefaultValue = {
 const PropertySchemaShape = {
   type: Type.OBJECT,
   properties: {
-    minimum: { type: Type.NUMBER },
-    maximum: { type: Type.NUMBER },
-    exclusiveMinimum: { type: Type.BOOLEAN },
-    exclusiveMaximum: { type: Type.BOOLEAN },
-    multipleOf: { type: Type.NUMBER },
-    enum: { type: Type.ARRAY, items: { type: Type.STRING } },
-    examples: { type: Type.ARRAY, items: { type: Type.STRING } },
-    defaultValue: SchemaDefaultValue,
-    pattern: { type: Type.STRING },
+    minimum: { type: Type.NUMBER, nullable: true },
+    maximum: { type: Type.NUMBER, nullable: true },
+    exclusiveMinimum: { type: Type.BOOLEAN, nullable: true },
+    exclusiveMaximum: { type: Type.BOOLEAN, nullable: true },
+    multipleOf: { type: Type.NUMBER, nullable: true },
+    enum: { type: Type.ARRAY, items: { type: Type.STRING }, nullable: true },
+    examples: { type: Type.ARRAY, items: { type: Type.STRING }, nullable: true },
+    defaultValue: { ...SchemaDefaultValue, nullable: true },
+    pattern: { type: Type.STRING, nullable: true },
   },
 }
 
 const PropertyConstraintsSchema = {
   type: Type.OBJECT,
   properties: {
-    required: { type: Type.BOOLEAN },
-    unique: { type: Type.BOOLEAN },
-    index: { type: Type.BOOLEAN },
-    primary: { type: Type.BOOLEAN },
-    multiple: { type: Type.BOOLEAN },
-    readOnly: { type: Type.BOOLEAN },
-    writeOnly: { type: Type.BOOLEAN },
+    required: { type: Type.BOOLEAN, nullable: true },
+    unique: { type: Type.BOOLEAN, nullable: true },
+    index: { type: Type.BOOLEAN, nullable: true },
+    primary: { type: Type.BOOLEAN, nullable: true },
+    multiple: { type: Type.BOOLEAN, nullable: true },
+    readOnly: { type: Type.BOOLEAN, nullable: true },
+    writeOnly: { type: Type.BOOLEAN, nullable: true },
   },
 }
 
@@ -74,7 +86,7 @@ const PropertySchema = {
       items: SemanticSchema,
       description: "List of semantics applied to this property. Note: ONLY use semantics with scope='property'.",
     },
-    tags: { type: Type.ARRAY, items: { type: Type.STRING } },
+    tags: { type: Type.ARRAY, items: { type: Type.STRING }, nullable: true },
   },
   required: ['key', 'name', 'type', 'displayName', 'description'],
 }
@@ -97,7 +109,7 @@ const AssociationSchema = {
     name: { type: Type.STRING },
     displayName: { type: Type.STRING },
     description: { type: Type.STRING },
-    targets: { type: Type.ARRAY, items: { type: Type.STRING }, description: 'List of target entity keys' },
+    targets: { type: Type.ARRAY, items: AssociationTarget },
     required: { type: Type.BOOLEAN },
     multiple: {
       type: Type.BOOLEAN,
@@ -150,6 +162,9 @@ const EntitySchema = {
   required: ['key', 'name', 'modelKey', 'displayName', 'description'],
 }
 
+/**
+ * Allows modifying a property (not adding)
+ */
 const PropertyDeltaSchema = {
   type: Type.OBJECT,
   properties: {
@@ -161,9 +176,9 @@ const PropertyDeltaSchema = {
       type: Type.STRING,
       description: 'Enum: string, number, boolean, date, datetime, time, binary',
     },
-    constraints: PropertyConstraintsSchema,
-    deprecated: { type: Type.BOOLEAN },
-    schema: PropertySchemaShape,
+    constraints: { ...PropertyConstraintsSchema, nullable: true },
+    deprecated: { type: Type.BOOLEAN, nullable: true },
+    schema: { ...PropertySchemaShape, nullable: true },
     addedSemantics: {
       type: Type.ARRAY,
       items: SemanticSchema,
@@ -182,13 +197,14 @@ const AssociationDeltaSchema = {
     name: { type: Type.STRING },
     displayName: { type: Type.STRING },
     description: { type: Type.STRING },
-    targets: { type: Type.ARRAY, items: { type: Type.STRING } },
-    required: { type: Type.BOOLEAN },
+    targets: { type: Type.ARRAY, items: AssociationTarget },
+    required: { type: Type.BOOLEAN, nullable: true },
     multiple: {
       type: Type.BOOLEAN,
+      nullable: true,
       description: 'Whether the association can have multiple targets (like User has multiple addresses)',
     },
-    onDelete: { type: Type.STRING, description: 'Enum: restrict, cascade, setNull, doNothing' },
+    onDelete: { type: Type.STRING, nullable: true, description: 'Enum: restrict, cascade, setNull, doNothing' },
     addedSemantics: {
       type: Type.ARRAY,
       items: SemanticSchema,
@@ -256,7 +272,7 @@ export const DOMAIN_SCHEMA = {
               name: { type: Type.STRING },
               displayName: { type: Type.STRING },
               description: { type: Type.STRING },
-              tags: { type: Type.ARRAY, items: { type: Type.STRING } },
+              tags: { type: Type.ARRAY, items: { type: Type.STRING }, nullable: true },
               addedSemantics: {
                 type: Type.ARRAY,
                 items: SemanticSchema,

package/src/modeling/ai/prompts/domain_system.ts

@@ -19,13 +19,12 @@ The \`reasoning\` string in your JSON output is the presentation layer. It will
 - **Keep it Conversational:** Use simple markdown (like bullet points) to provide a friendly, easily scannable summary of what you built for them.
 - **Proactive Next Steps:** Always conclude your summary with a single, highly relevant question asking the user what they want to do next. Base this on what you just built or what might be missing.
 
-# REFERENTIAL INTEGRITY (NO PHANTOM KEYS)
-You must absolutely guarantee that every key listed in an association's \`targets\` array actually exists. 
-- **The Target Rule:** A target key is ONLY valid if it meets one of two conditions:
-  1. It is the exact \`key\` of an entity you are actively creating in the \`addedEntities\` array in this exact response.
-  2. It is the exact \`key\` of an entity explicitly provided to you in the Current Domain context.
-- **ANTI-PATTERN:** Inventing a logical target key (e.g., \`resource_entity\`, \`user_id\`) that does not exist in the context or your current payload. 
-- **Missing Targets:** If the user asks you to link to an entity that does not exist, you MUST create that missing entity in \`addedEntities\` first so you have a valid key to target.
+# REFERENTIAL INTEGRITY (STRICT KEYS ONLY)
+You must absolutely guarantee that you never hallucinate or invent a \`key\` for an existing object. 
+- **Modifications & Deletions:** When adding objects to \`modifiedModels\`, \`modifiedEntities\`, \`deletedModelKeys\`, or \`deletedEntityKeys\`, the \`key\` you use MUST be an exact match to an existing \`nanoid\` key provided to you in the Current Domain Context.
+- **Association Targets:** A target key in an association is ONLY valid if it exists in the Current Domain Context, or if you are actively creating it in \`addedEntities\`.
+- **ANTI-PATTERN:** Inventing a placeholder key to modify an object that you don't know the exact nanoid for.
+- **Handling Missing Objects:** If the user asks you to modify an entity but it does not exist in the provided context, you MUST assume it is a brand new entity. Define its complete schema inside \`addedEntities\` instead of trying to modify a phantom key.
 
 # CREATION & DEPENDENCY LOGIC (THE TWO-PASS RULE)
 When creating multiple new entities that relate to one another, you must respect referential integrity. You cannot reference an entity in an association before it exists.
@@ -76,4 +75,10 @@ You are an enterprise Data Architect. You must actively defend against malicious
 - **Conciseness:** If an operation requires more than 10 properties, suggest splitting the task into two parts rather than outputting one massive JSON array.
 - **No Encoding:** Never attempt to output Base64, Hex, or encoded strings unless explicitly requested for a \`binary\` type.
 - **Loop Prevention:** If you find yourself repeating the same key or value more than 5 times in a single array, stop and ask the user for clarification.
+
+# PARTIAL UPDATES & DELETIONS
+When modifying existing objects in the \`modifiedEntities\` or \`modifiedModels\` arrays, use strict partial-update logic:
+- **To update a value:** Provide the key and the new value.
+- **To leave a value unchanged:** Completely omit the key from the JSON object. Do not output it.
+- **To delete an existing value:** You MUST explicitly output the key with a value of \`null\` (e.g., \`"description": null\`).
 `

package/src/modeling/ai/types.ts

@@ -132,7 +132,7 @@ export interface AiDomainProperty {
   deprecated?: boolean
   schema?: PropertySchema
   semantics?: AiDomainSemantic[]
-  tags?: string[]
+  tags?: string[] | null
 }
 
 /**
@@ -226,7 +226,7 @@ export interface AiDomainEntityDelta {
   name?: string
   displayName?: string
   description?: string
-  tags?: string[]
+  tags?: string[] | null
   // Entity semantics delta
   addedSemantics?: AiDomainSemantic[]
   modifiedSemantics?: AiDomainSemantic[]
@@ -240,6 +240,10 @@ export interface AiDomainEntityDelta {
   deletedAssociationKeys?: string[]
 }
 
+export type NullablePropertySchema = {
+  [K in keyof PropertySchema]?: PropertySchema[K] | null
+}
+
 /**
  * Represents a targeted modification to an existing property generated by the AI.
  * It captures changes to superficial properties (name, description), type changes,
@@ -252,20 +256,20 @@ export interface AiDomainPropertyDelta {
   description?: string
   type?: DomainPropertyType
   constraints?: {
-    required?: boolean
-    unique?: boolean
-    index?: boolean
-    primary?: boolean
-    multiple?: boolean
-    readOnly?: boolean
-    writeOnly?: boolean
-  }
-  deprecated?: boolean
+    required?: boolean | null
+    unique?: boolean | null
+    index?: boolean | null
+    primary?: boolean | null
+    multiple?: boolean | null
+    readOnly?: boolean | null
+    writeOnly?: boolean | null
+  } | null
+  deprecated?: boolean | null
   // Property semantics delta
   addedSemantics?: AiDomainSemantic[]
   modifiedSemantics?: AiDomainSemantic[]
   deletedSemanticIds?: SemanticType[]
-  schema?: PropertySchema
+  schema?: NullablePropertySchema
 }
 
 /**
@@ -279,8 +283,9 @@ export interface AiDomainAssociationDelta {
   displayName?: string
   description?: string
   targets?: AssociationTarget[]
-  required?: boolean
-  onDelete?: OnDeleteRule
+  required?: boolean | null
+  multiple?: boolean | null
+  onDelete?: OnDeleteRule | null
   // Association semantics delta
   addedSemantics?: AiDomainSemantic[]
   modifiedSemantics?: AiDomainSemantic[]

package/tests/unit/modeling/ai/DataDomainDelta.spec.ts

@@ -189,6 +189,116 @@ test.group('DataDomainDelta.apply()', () => {
     assert.equal(prop2!.info.name, 'New Prop')
   })
 
+  test('unsets properties, constraints, schema, and association options using null values', ({ assert }) => {
+    const domain = new DataDomain()
+    const model = domain.addModel()
+    const entity = domain.addEntity(model.key, { info: { name: 'unset-entity' }, tags: ['tag1'] })
+
+    entity.addProperty({
+      key: 'prop1',
+      type: 'string',
+      deprecated: true,
+      required: true,
+      unique: true,
+      index: true,
+      primary: true,
+      multiple: true,
+      readOnly: true,
+      writeOnly: true,
+      schema: {
+        defaultValue: { type: 'literal', value: 'foo' },
+        pattern: '^[a-z]+$',
+        minimum: 1,
+        maximum: 10,
+        exclusiveMinimum: true,
+        exclusiveMaximum: true,
+        multipleOf: 2,
+        enum: ['foo', 'bar'],
+        examples: ['foo'],
+      },
+    })
+
+    entity.addAssociation({
+      key: 'assoc1',
+      required: true,
+      multiple: true,
+      onDelete: 'cascade',
+    })
+
+    const delta = {
+      modifiedEntities: [
+        {
+          key: entity.key,
+          tags: null,
+          modifiedProperties: [
+            {
+              key: 'prop1',
+              deprecated: null,
+              constraints: {
+                required: null,
+                unique: null,
+                index: null,
+                primary: null,
+                multiple: null,
+                readOnly: null,
+                writeOnly: null,
+              },
+              schema: {
+                defaultValue: null,
+                pattern: null,
+                minimum: null,
+                maximum: null,
+                exclusiveMinimum: null,
+                exclusiveMaximum: null,
+                multipleOf: null,
+                enum: null,
+                examples: null,
+              },
+            },
+          ],
+          modifiedAssociations: [
+            {
+              key: 'assoc1',
+              required: null,
+              multiple: null,
+              onDelete: null,
+            },
+          ],
+        },
+      ],
+    }
+
+    const instance = new DataDomainDelta(domain)
+    instance.apply(delta)
+
+    assert.lengthOf(entity.tags, 0)
+
+    const prop1 = domain.findProperty('prop1')!
+    assert.isUndefined(prop1.deprecated)
+    assert.isUndefined(prop1.required)
+    assert.isUndefined(prop1.unique)
+    assert.isUndefined(prop1.index)
+    assert.isUndefined(prop1.primary)
+    assert.isUndefined(prop1.multiple)
+    assert.isUndefined(prop1.readOnly)
+    assert.isUndefined(prop1.writeOnly)
+
+    assert.isUndefined(prop1.schema?.defaultValue)
+    assert.isUndefined(prop1.schema?.pattern)
+    assert.isUndefined(prop1.schema?.minimum)
+    assert.isUndefined(prop1.schema?.maximum)
+    assert.isUndefined(prop1.schema?.exclusiveMinimum)
+    assert.isUndefined(prop1.schema?.exclusiveMaximum)
+    assert.isUndefined(prop1.schema?.multipleOf)
+    assert.isUndefined(prop1.schema?.enum)
+    assert.isUndefined(prop1.schema?.examples)
+
+    const assoc1 = domain.findAssociation('assoc1')!
+    assert.isUndefined(assoc1.required)
+    assert.isUndefined(assoc1.multiple)
+    assert.isUndefined(assoc1.onDelete)
+  })
+
   test('deletes entity properties', ({ assert }) => {
     const domain = new DataDomain()
     const model = domain.addModel()