@api-client/core 0.19.23 → 0.19.25

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'])
 })

package/tests/unit/models/store/CustomDomain.spec.ts

@@ -0,0 +1,111 @@
+import { test } from '@japa/runner'
+import { CustomDomainModel } from '../../../../src/models/store/CustomDomain.js'
+import type { CustomDomainSchema } from '../../../../src/models/store/CustomDomain.js'
+
+test.group('CustomDomain model', () => {
+  test('createSchema() returns default values', ({ assert }) => {
+    const result = CustomDomainModel.createSchema()
+    assert.isString(result.id)
+    assert.equal(result.orgId, '')
+    assert.equal(result.domain, '')
+    assert.equal(result.dnsTarget, '')
+    assert.isFalse(result.dnsVerified)
+    assert.isUndefined(result.lastVerifiedAt)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<CustomDomainSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsTarget: 'target.example.com',
+      dnsVerified: true,
+      lastVerifiedAt: 11111,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = CustomDomainModel.createSchema(init)
+    assert.equal(result.id, 'test-id')
+    assert.equal(result.orgId, 'org-1')
+    assert.equal(result.domain, 'api.example.com')
+    assert.equal(result.dnsTarget, 'target.example.com')
+    assert.isTrue(result.dnsVerified)
+    assert.equal(result.lastVerifiedAt, 11111)
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const model = new CustomDomainModel()
+    assert.isString(model.id)
+    assert.equal(model.orgId, '')
+    assert.equal(model.domain, '')
+    assert.equal(model.dnsTarget, '')
+    assert.isFalse(model.dnsVerified)
+    assert.isUndefined(model.lastVerifiedAt)
+    assert.isNumber(model.createdAt)
+    assert.isNumber(model.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<CustomDomainSchema> = {
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsVerified: true,
+    }
+    const model = new CustomDomainModel(init)
+    assert.equal(model.orgId, 'org-1')
+    assert.equal(model.domain, 'api.example.com')
+    assert.isTrue(model.dnsVerified)
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<CustomDomainSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsTarget: 'target.example.com',
+      dnsVerified: true,
+      lastVerifiedAt: 11111,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const model = new CustomDomainModel(init)
+    const result = model.toJSON()
+    assert.deepEqual(result, {
+      id: 'test-id',
+      orgId: 'org-1',
+      domain: 'api.example.com',
+      dnsTarget: 'target.example.com',
+      dnsVerified: true,
+      lastVerifiedAt: 11111,
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty fields', ({ assert }) => {
+    const model = new CustomDomainModel({
+      domain: '',
+      orgId: '',
+      dnsTarget: '',
+    })
+    const errors = model.validate()
+    assert.lengthOf(errors, 3)
+    assert.deepEqual(errors[0], { field: 'domain', message: 'Domain must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[1], { field: 'orgId', message: 'Org ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[2], { field: 'dnsTarget', message: 'DNS target must not be empty', rule: 'notEmpty' })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const model = new CustomDomainModel({
+      domain: 'api.example.com',
+      orgId: 'org-1',
+      dnsTarget: 'target.example.com',
+    })
+    const errors = model.validate()
+    assert.lengthOf(errors, 0)
+  })
+})

package/tests/unit/models/store/Deployment.spec.ts

@@ -0,0 +1,198 @@
+import { test } from '@japa/runner'
+import { Deployment, DeploymentEnvironment, DeploymentStatus } from '../../../../src/models/store/Deployment.js'
+import type { DeploymentSchema } from '../../../../src/models/store/Deployment.js'
+
+test.group('Deployment model', () => {
+  test('createSchema() returns default values', ({ assert }) => {
+    const result = Deployment.createSchema()
+    assert.isString(result.key)
+    assert.equal(result.orgId, '')
+    assert.equal(result.apiId, '')
+    assert.equal(result.orgSlug, '')
+    assert.equal(result.apiSlug, '')
+    assert.equal(result.env, DeploymentEnvironment.DEV)
+    assert.isUndefined(result.version)
+    assert.equal(result.modelVersion, '0.0.0')
+    assert.equal(result.status, DeploymentStatus.Pending)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      key: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      version: 'v1',
+      modelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = Deployment.createSchema(init)
+    assert.equal(result.key, 'test-id')
+    assert.equal(result.orgId, 'org-1')
+    assert.equal(result.apiId, 'api-1')
+    assert.equal(result.orgSlug, 'org-slug')
+    assert.equal(result.apiSlug, 'api-slug')
+    assert.equal(result.env, DeploymentEnvironment.PROD)
+    assert.equal(result.version, 'v1')
+    assert.equal(result.modelVersion, '1.0.0')
+    assert.equal(result.status, DeploymentStatus.Active)
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const deployment = new Deployment()
+    assert.isString(deployment.key)
+    assert.equal(deployment.orgId, '')
+    assert.equal(deployment.apiId, '')
+    assert.equal(deployment.orgSlug, '')
+    assert.equal(deployment.apiSlug, '')
+    assert.equal(deployment.env, DeploymentEnvironment.DEV)
+    assert.isUndefined(deployment.version)
+    assert.equal(deployment.modelVersion, '0.0.0')
+    assert.equal(deployment.status, DeploymentStatus.Pending)
+    assert.isNumber(deployment.createdAt)
+    assert.isNumber(deployment.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      orgId: 'org-1',
+      apiId: 'api-1',
+    }
+    const deployment = new Deployment(init)
+    assert.equal(deployment.orgId, 'org-1')
+    assert.equal(deployment.apiId, 'api-1')
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      key: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      version: 'v1',
+      modelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const deployment = new Deployment(init)
+    const result = deployment.toJSON()
+    assert.deepEqual(result, {
+      kind: 'Core#Deployment',
+      key: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      version: 'v1',
+      modelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty fields', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: '',
+      apiId: '',
+      orgSlug: '',
+      apiSlug: '',
+      env: '' as any, // Force empty env
+    })
+    deployment.version = ''
+    deployment.modelVersion = ''
+    const errors = deployment.validate()
+    // It should now return errors for orgId, apiId, orgSlug, apiSlug, env, modelVersion
+    // Note: Since env is empty, the version-prod logic won't hit the first branch, but might hit the second branch
+    // if version is present. Since version='', neither branch hits.
+    assert.lengthOf(errors, 6)
+    assert.deepEqual(errors[0], { field: 'orgId', message: 'Org ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[1], { field: 'apiId', message: 'API ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[2], { field: 'orgSlug', message: 'Org slug must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[3], { field: 'apiSlug', message: 'API slug must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[4], { field: 'env', message: 'Environment tag must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[5], {
+      field: 'modelVersion',
+      message: 'API model version must not be empty',
+      rule: 'notEmpty',
+    })
+  })
+
+  test('validate() returns error if version is empty for PROD environment', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      modelVersion: '1.0.0',
+    })
+    // Version is undefined by default, or we can explicitly set it to empty string
+    deployment.version = ''
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 1)
+    assert.deepEqual(errors[0], {
+      field: 'version',
+      message: 'Version must not be empty for production environment',
+      rule: 'notEmpty',
+    })
+  })
+
+  test('validate() returns error if version is present for non-PROD environment', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.DEV,
+      version: 'v1',
+      modelVersion: '1.0.0',
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 1)
+    assert.deepEqual(errors[0], {
+      field: 'version',
+      message: 'Version must not be present for non-production environment',
+      rule: 'notEmpty',
+    })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      version: 'v1',
+      modelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 0)
+  })
+
+  test('validate() returns no errors for valid non-PROD model', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      modelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.DEV,
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 0)
+  })
+})

package/tests/unit/models/store/DeploymentCustomDomain.spec.ts

@@ -0,0 +1,122 @@
+import { test } from '@japa/runner'
+import { DeploymentCustomDomainModel, SslStatus } from '../../../../src/models/store/DeploymentCustomDomain.js'
+import type { DeploymentCustomDomainSchema } from '../../../../src/models/store/DeploymentCustomDomain.js'
+
+test.group('DeploymentCustomDomain model', () => {
+  test('createSchema() returns default values', ({ assert }) => {
+    const result = DeploymentCustomDomainModel.createSchema()
+    assert.isString(result.id)
+    assert.equal(result.deploymentId, '')
+    assert.equal(result.customDomainId, '')
+    assert.equal(result.basePath, '/')
+    assert.equal(result.sslStatus, SslStatus.PendingDns)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentCustomDomainSchema> = {
+      id: 'test-id',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+      sslStatus: SslStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = DeploymentCustomDomainModel.createSchema(init)
+    assert.equal(result.id, 'test-id')
+    assert.equal(result.deploymentId, 'dep-1')
+    assert.equal(result.customDomainId, 'dom-1')
+    assert.equal(result.basePath, '/api')
+    assert.equal(result.sslStatus, SslStatus.Active)
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const model = new DeploymentCustomDomainModel()
+    assert.isString(model.id)
+    assert.equal(model.deploymentId, '')
+    assert.equal(model.customDomainId, '')
+    assert.equal(model.basePath, '/')
+    assert.equal(model.sslStatus, SslStatus.PendingDns)
+    assert.isNumber(model.createdAt)
+    assert.isNumber(model.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentCustomDomainSchema> = {
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+    }
+    const model = new DeploymentCustomDomainModel(init)
+    assert.equal(model.deploymentId, 'dep-1')
+    assert.equal(model.customDomainId, 'dom-1')
+    assert.equal(model.basePath, '/api')
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<DeploymentCustomDomainSchema> = {
+      id: 'test-id',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+      sslStatus: SslStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const model = new DeploymentCustomDomainModel(init)
+    const result = model.toJSON()
+    assert.deepEqual(result, {
+      id: 'test-id',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+      sslStatus: SslStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty and invalid fields', ({ assert }) => {
+    const model = new DeploymentCustomDomainModel({
+      basePath: '',
+      deploymentId: '',
+      customDomainId: '',
+    })
+    let errors = model.validate()
+    assert.lengthOf(errors, 3)
+    assert.deepEqual(errors[0], { field: 'basePath', message: 'Base path must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[1], { field: 'deploymentId', message: 'Deployment ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[2], {
+      field: 'customDomainId',
+      message: 'Custom domain ID must not be empty',
+      rule: 'notEmpty',
+    })
+
+    const modelInvalidPath = new DeploymentCustomDomainModel({
+      basePath: 'api/path',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+    })
+    errors = modelInvalidPath.validate()
+    assert.lengthOf(errors, 1)
+    assert.deepEqual(errors[0], {
+      field: 'basePath',
+      message: 'Base path must start with a slash',
+      rule: 'startsWithSlash',
+    })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const model = new DeploymentCustomDomainModel({
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+    })
+    const errors = model.validate()
+    assert.lengthOf(errors, 0)
+  })
+})