@api-client/core 0.19.24 → 0.19.25

package/src/sdk/Sdk.ts

@@ -13,6 +13,7 @@ import { OrganizationsSdk } from './OrganizationsSdk.js'
 import { DataCatalogSdk } from './DataCatalogSdk.js'
 import { GroupsSdk } from './GroupsSdk.js'
 import { AiSdk } from './AiSdk.js'
+import { DeploymentsSdk } from './DeploymentsSdk.js'
 
 const baseUriSymbol = Symbol('baseUri')
 
@@ -84,6 +85,8 @@ export abstract class Sdk {
   groups = new GroupsSdk(this)
 
   ai = new AiSdk(this)
+
+  deployments = new DeploymentsSdk(this)
   /**
    * When set it limits log output to minimum.
    */

package/src/sdk/SdkBase.ts

@@ -208,7 +208,7 @@ export class SdkBase {
   }
 
   protected readResponseBody(response: IStoreResponse, errorPrefix: string): string {
-    if (response.status !== 200) {
+    if (![200, 202].includes(response.status)) {
       this.logInvalidResponse(response)
       throw this.createApiError(`${errorPrefix}${E_RESPONSE_STATUS}${response.status}`, response.body)
     }
@@ -221,9 +221,15 @@ export class SdkBase {
     return response.body
   }
 
-  protected readResponseJSON(response: IStoreResponse, errorPrefix: string): unknown {
+  /**
+   * A helper function that asserts the `body` is set and it is a valid JSON.
+   * @param response The response that is expected to have a valid JSON on the `body`
+   * @param errorPrefix The error prefix for the errors thrown
+   * @returns The valid JSON response object
+   */
+  protected readResponseJSON<T = unknown>(response: IStoreResponse, errorPrefix: string): T {
     const body = this.readResponseBody(response, errorPrefix)
-    let data: unknown
+    let data: T
     try {
       data = JSON.parse(body)
     } catch {
@@ -231,4 +237,30 @@ export class SdkBase {
     }
     return data
   }
+
+  /**
+   * A helper function to process List response.
+   * The list response is standardised response containing the `items` and `cursor` properties.
+   * The list response also returns 200 status code. The logic validates the JSON response,
+   * 200 status code, and whether the response the `items` array (can be empty).
+   *
+   * @param result The read results of a standard List request
+   * @param prefix The error prefix to use with the error codes.
+   * @returns The valid list results.
+   */
+  protected processListResponse<T = unknown>(result: IStoreResponse, prefix: string): ContextListResult<T> {
+    this.inspectCommonStatusCodes(result)
+    // Status check happens in the readResponseBody method.
+    const data = this.readResponseJSON<ContextListResult<T>>(result, prefix)
+    if (!Array.isArray(data.items)) {
+      throw new Exception(`${prefix}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: result.status })
+    }
+    return data
+  }
+
+  protected assertObjectKind(prefix: string, expected: string, actual?: unknown): void {
+    if (expected !== actual) {
+      throw new Exception(`${prefix}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: 500 })
+    }
+  }
 }

package/src/sdk/SdkMock.ts

@@ -27,6 +27,9 @@ import type { ForeignDomainDependency } from '../modeling/types.js'
 import { nanoid } from '../nanoid.js'
 import type { AiSessionSchema, AiSessionApp } from '../models/AiSession.js'
 import type { AiMessageSchema } from '../models/AiMessage.js'
+import type { DeploymentSchema } from '../models/store/Deployment.js'
+import { DeploymentEnvironment } from '../models/store/Deployment.js'
+import type { CreateDeploymentPayload } from './DeploymentsSdk.js'
 
 export interface MockResult {
   /**
@@ -1614,6 +1617,106 @@ export class SdkMock {
     },
   }
 
+  /**
+   * Deployments API mocks.
+   */
+  deployments = {
+    list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<DeploymentSchema> = {
+            items: this.gen.deployments.deployments(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.deployments(':oid'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
+    },
+    create: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      const respond = this.createDefaultResponse(
+        202,
+        { 'content-type': 'application/json' },
+        (req: SerializedRequest) => {
+          const raw = req.body as string
+          const payload = JSON.parse(raw) as CreateDeploymentPayload
+          const obj = this.gen.deployments.deployment({
+            orgId: req.params.oid,
+            apiId: payload.fid,
+            modelVersion: payload.modelVersion,
+            env: payload.env,
+            ...(payload.env === DeploymentEnvironment.PROD ? { version: payload.version } : {}),
+          })
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.deployments(':oid'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
+    },
+    read: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        (req: SerializedRequest) => {
+          const obj = this.gen.deployments.deployment({
+            key: req.params.id,
+            orgId: req.params.oid,
+          })
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.deployment(':oid', ':id'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
+    },
+    deactivate: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.deployment(':oid', ':id'),
+            methods: ['DELETE'],
+          },
+          respond,
+        },
+        options
+      )
+    },
+  }
+
   /**
    * Trash Data Catalog mocks.
    */

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

@@ -0,0 +1,122 @@
+import { test } from '@japa/runner'
+import { ApiModel } from '../../../src/modeling/ApiModel.js'
+import { RuntimeApiModel, type RuntimeApiModelSchema } from '../../../src/modeling/RuntimeApiModel.js'
+import { DataDomain } from '../../../src/modeling/DataDomain.js'
+
+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 baseModel = new ApiModel(
+      {
+        key: 'api-1',
+        info: { name: 'Test API' },
+      },
+      domain
+    )
+
+    const expose = baseModel.exposeEntity({ key: entity.key })
+    expose.setResourcePath('/users/{id}')
+    expose.addActionFromKind('read')
+
+    const schema: RuntimeApiModelSchema = {
+      ...baseModel.toJSON(),
+      routingMap: {
+        GET: [{ path: '/users/{id}', lookup: { exposedEntityKey: expose.key, actionKind: 'read' } }],
+      },
+    }
+
+    const runtimeModel = new RuntimeApiModel(schema, domain.toJSON())
+    assert.deepEqual(runtimeModel.toJSON().routingMap, schema.routingMap)
+  }).tags(['@modeling', '@runtime'])
+
+  test('resolves path with matchit', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const schema = {
+      key: 'api-1',
+      info: { name: 'Test API' },
+      exposes: [
+        {
+          key: 'expose-1',
+          entity: { key: 'ent-1', type: 'association' },
+          actions: [
+            { kind: 'read', type: 'crud' },
+            { kind: 'list', type: 'crud' },
+          ],
+        },
+      ],
+      routingMap: {
+        GET: [
+          { path: '/users/{id}', lookup: { exposedEntityKey: 'expose-1', actionKind: 'read' } },
+          { path: '/users', lookup: { exposedEntityKey: 'expose-1', actionKind: 'list' } },
+        ],
+      },
+    }
+
+    const runtimeModel = new RuntimeApiModel(schema as any, domain.toJSON())
+
+    const listResult = runtimeModel.lookupAction('GET', '/users')
+    assert.isOk(listResult)
+    assert.equal(listResult!.action.kind, 'list')
+    assert.deepEqual(listResult!.params, {})
+
+    const readResult = runtimeModel.lookupAction('get', '/users/123') // Case insensitivity test
+    assert.isOk(readResult)
+    assert.equal(readResult!.action.kind, 'read')
+    assert.deepEqual(readResult!.params, { id: '123' })
+  }).tags(['@modeling', '@runtime'])
+
+  test('returns undefined for unknown routes', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const schema = {
+      key: 'api-1',
+      info: { name: 'Test API' },
+      routingMap: {
+        GET: [{ path: '/users', lookup: { exposedEntityKey: 'expose-1', actionKind: 'list' } }],
+      },
+    }
+
+    const runtimeModel = new RuntimeApiModel(schema as any, domain.toJSON())
+
+    // Method not found
+    const postResult = runtimeModel.lookupAction('POST', '/users')
+    assert.isUndefined(postResult)
+
+    // Method found, path not found
+    const getResult = runtimeModel.lookupAction('GET', '/unknown')
+    assert.isUndefined(getResult)
+  }).tags(['@modeling', '@runtime'])
+
+  test('returns undefined when entity or action is missing', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const schema = {
+      key: 'api-1',
+      info: { name: 'Test API' },
+      exposes: [
+        {
+          key: 'expose-1',
+          entity: { key: 'ent-1', type: 'association' },
+          actions: [{ kind: 'list', type: 'crud' }],
+        },
+      ],
+      routingMap: {
+        GET: [
+          { path: '/missing-entity', lookup: { exposedEntityKey: 'missing-expose', actionKind: 'list' } },
+          { path: '/missing-action', lookup: { exposedEntityKey: 'expose-1', actionKind: 'read' } },
+        ],
+      },
+    }
+
+    const runtimeModel = new RuntimeApiModel(schema as any, domain.toJSON())
+
+    // Exposed entity not found
+    const missingEntityResult = runtimeModel.lookupAction('GET', '/missing-entity')
+    assert.isUndefined(missingEntityResult)
+
+    // Action not found on entity
+    const missingActionResult = runtimeModel.lookupAction('GET', '/missing-action')
+    assert.isUndefined(missingActionResult)
+  }).tags(['@modeling', '@runtime'])
+})

package/tests/unit/modeling/actions/index.spec.ts

@@ -0,0 +1,113 @@
+import { test } from '@japa/runner'
+import { createActionFromKind, restoreAction, type ActionKind } from '../../../../src/modeling/actions/index.js'
+import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
+import { ReadAction } from '../../../../src/modeling/actions/ReadAction.js'
+import { CreateAction } from '../../../../src/modeling/actions/CreateAction.js'
+import { UpdateAction } from '../../../../src/modeling/actions/UpdateAction.js'
+import { DeleteAction } from '../../../../src/modeling/actions/DeleteAction.js'
+import { SearchAction } from '../../../../src/modeling/actions/SearchAction.js'
+import { DataDomain } from '../../../../src/modeling/DataDomain.js'
+import { ApiModel } from '../../../../src/modeling/ApiModel.js'
+import type { ExposedEntity } from '../../../../src/modeling/ExposedEntity.js'
+
+test.group('modeling/actions/index', (group) => {
+  let domain: DataDomain
+  let baseModel: ApiModel
+  let expose: ExposedEntity
+
+  group.each.setup(() => {
+    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' } })
+
+    baseModel = new ApiModel(
+      {
+        key: 'api-1',
+        info: { name: 'Test API' },
+      },
+      domain
+    )
+
+    expose = baseModel.exposeEntity({ key: entity.key })
+  })
+
+  test('createActionFromKind: creates ListAction', ({ assert }) => {
+    const action = createActionFromKind(expose, 'list')
+    assert.instanceOf(action, ListAction)
+    assert.equal(action.kind, 'list')
+  }).tags(['@actions'])
+
+  test('createActionFromKind: creates ReadAction', ({ assert }) => {
+    const action = createActionFromKind(expose, 'read')
+    assert.instanceOf(action, ReadAction)
+    assert.equal(action.kind, 'read')
+  }).tags(['@actions'])
+
+  test('createActionFromKind: creates CreateAction', ({ assert }) => {
+    const action = createActionFromKind(expose, 'create')
+    assert.instanceOf(action, CreateAction)
+    assert.equal(action.kind, 'create')
+  }).tags(['@actions'])
+
+  test('createActionFromKind: creates UpdateAction', ({ assert }) => {
+    const action = createActionFromKind(expose, 'update')
+    assert.instanceOf(action, UpdateAction)
+    assert.equal(action.kind, 'update')
+  }).tags(['@actions'])
+
+  test('createActionFromKind: creates DeleteAction', ({ assert }) => {
+    const action = createActionFromKind(expose, 'delete')
+    assert.instanceOf(action, DeleteAction)
+    assert.equal(action.kind, 'delete')
+  }).tags(['@actions'])
+
+  test('createActionFromKind: creates SearchAction', ({ assert }) => {
+    const action = createActionFromKind(expose, 'search')
+    assert.instanceOf(action, SearchAction)
+    assert.equal(action.kind, 'search')
+  }).tags(['@actions'])
+
+  test('createActionFromKind: throws exception for unknown action kind', ({ assert }) => {
+    assert.throws(() => createActionFromKind(expose, 'unknown' as ActionKind), 'Unknown action kind')
+  }).tags(['@actions'])
+
+  test('restoreAction: restores ListAction', ({ assert }) => {
+    const action = restoreAction(expose, { kind: 'list' })
+    assert.instanceOf(action, ListAction)
+    assert.equal(action.kind, 'list')
+  }).tags(['@actions'])
+
+  test('restoreAction: restores ReadAction', ({ assert }) => {
+    const action = restoreAction(expose, { kind: 'read' })
+    assert.instanceOf(action, ReadAction)
+    assert.equal(action.kind, 'read')
+  }).tags(['@actions'])
+
+  test('restoreAction: restores CreateAction', ({ assert }) => {
+    const action = restoreAction(expose, { kind: 'create' })
+    assert.instanceOf(action, CreateAction)
+    assert.equal(action.kind, 'create')
+  }).tags(['@actions'])
+
+  test('restoreAction: restores UpdateAction', ({ assert }) => {
+    const action = restoreAction(expose, { kind: 'update' })
+    assert.instanceOf(action, UpdateAction)
+    assert.equal(action.kind, 'update')
+  }).tags(['@actions'])
+
+  test('restoreAction: restores DeleteAction', ({ assert }) => {
+    const action = restoreAction(expose, { kind: 'delete' })
+    assert.instanceOf(action, DeleteAction)
+    assert.equal(action.kind, 'delete')
+  }).tags(['@actions'])
+
+  test('restoreAction: restores SearchAction', ({ assert }) => {
+    const action = restoreAction(expose, { kind: 'search' })
+    assert.instanceOf(action, SearchAction)
+    assert.equal(action.kind, 'search')
+  }).tags(['@actions'])
+
+  test('restoreAction: throws exception for unknown action kind', ({ assert }) => {
+    assert.throws(() => restoreAction(expose, { kind: 'unknown' }), 'Unknown action kind')
+  }).tags(['@actions'])
+})

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

@@ -794,6 +794,34 @@ test.group('DomainAssociation.readBinding()', () => {
   })
 })
 
+test.group('DomainAssociation.readWebBinding()', () => {
+  test('returns undefined if no web binding exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const webBindings = association.readWebBinding()
+    assert.isUndefined(webBindings)
+  }).tags(['@modeling', '@association'])
+
+  test('returns the web binding schema if it exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent', {
+      bindings: [{ type: 'web', schema: { hidden: true } }],
+    })
+    const webBindings = association.readWebBinding()
+    assert.deepEqual(webBindings, { hidden: true })
+  }).tags(['@modeling', '@association'])
+
+  test('returns undefined if the web binding exists but has no schema', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent', {
+      // @ts-expect-error Testing undefined schema
+      bindings: [{ type: 'web', schema: undefined }],
+    })
+    const webBindings = association.readWebBinding()
+    assert.isUndefined(webBindings)
+  }).tags(['@modeling', '@association'])
+})
+
 test.group('DomainAssociation.addSemantic()', () => {
   test('adds a new semantic to the association', ({ assert }) => {
     const dataDomain = new DataDomain()

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

@@ -59,6 +59,55 @@ test.group('DomainEntity.listParents()', () => {
   })
 })
 
+test.group('DomainEntity.listAllParents()', () => {
+  test('lists all parent entities recursively upwards (default)', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const grandparent = model.addEntity({ key: 'grandparent' })
+    const parent = model.addEntity({ key: 'parent' })
+    const child = model.addEntity({ key: 'child' })
+    parent.addParent(grandparent.key)
+    child.addParent(parent.key)
+    const parents = child.listAllParents()
+    assert.deepEqual(parents, [parent, grandparent])
+  })
+
+  test('lists all parent entities recursively downwards', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const grandparent = model.addEntity({ key: 'grandparent' })
+    const parent = model.addEntity({ key: 'parent' })
+    const child = model.addEntity({ key: 'child' })
+    parent.addParent(grandparent.key)
+    child.addParent(parent.key)
+    const parents = child.listAllParents('down')
+    assert.deepEqual(parents, [grandparent, parent])
+  })
+
+  test('handles multiple inheritance properly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const grandparent1 = model.addEntity({ key: 'grandparent1' })
+    const grandparent2 = model.addEntity({ key: 'grandparent2' })
+    const parent1 = model.addEntity({ key: 'parent1' })
+    const parent2 = model.addEntity({ key: 'parent2' })
+    const child = model.addEntity({ key: 'child' })
+
+    parent1.addParent(grandparent1.key)
+    parent2.addParent(grandparent2.key)
+    child.addParent(parent1.key)
+    child.addParent(parent2.key)
+
+    const parentsUp = child.listAllParents('up')
+    // Order based on BFS: parent1, parent2, grandparent1, grandparent2
+    assert.deepEqual(parentsUp, [parent1, parent2, grandparent1, grandparent2])
+
+    const parentsDown = child.listAllParents('down')
+    // Order reversed: grandparent2, grandparent1, parent2, parent1
+    assert.deepEqual(parentsDown, [grandparent2, grandparent1, parent2, parent1])
+  })
+})
+
 test.group('DomainEntity.addParent()', () => {
   test('adds a parent to the entity', ({ assert }) => {
     const dataDomain = new DataDomain()

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

@@ -198,4 +198,51 @@ test.group('ExposedEntity::actions', (group) => {
     assert.equal(restoredAction.kind, 'search', 'Action kind should be search')
     assert.instanceOf(restoredAction, SearchAction, 'Action should be an instance of SearchAction')
   }).tags(['@modeling', '@action', '@restoring'])
+
+  test('addActionFromKind adds a new action', ({ assert }) => {
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            isRoot: true,
+            hasCollection: false,
+            resourcePath: '',
+            actions: [],
+          },
+        ],
+      },
+      domain
+    )
+    const expose = Array.from(model.exposes.values())[0]!
+    const action = expose.addActionFromKind('list')
+    assert.instanceOf(action, ListAction)
+    assert.equal(action.kind, 'list')
+    assert.lengthOf(expose.actions, 1)
+    assert.strictEqual(expose.actions[0], action)
+  }).tags(['@modeling', '@action'])
+
+  test('addActionFromKind throws if action already exists', ({ assert }) => {
+    const model = new ApiModel(
+      {
+        exposes: [
+          {
+            kind: ExposedEntityKind,
+            key: nanoid(),
+            entity: { key: entity.key },
+            isRoot: true,
+            hasCollection: false,
+            resourcePath: '',
+            actions: [],
+          },
+        ],
+      },
+      domain
+    )
+    const expose = Array.from(model.exposes.values())[0]!
+    expose.addActionFromKind('list')
+    assert.throws(() => expose.addActionFromKind('list'), 'Action of kind "list" already exists for this exposure')
+  }).tags(['@modeling', '@action'])
 })