@api-client/core 0.19.23 → 0.19.24

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.23",
+  "version": "0.19.24",
   "license": "UNLICENSED",
   "exports": {
     "./browser.js": {

package/src/models/store/CustomDomain.ts

@@ -0,0 +1,119 @@
+import type { FieldValidationMessage } from '../../exceptions/validation_error.js'
+import { nanoid } from '../../nanoid.js'
+
+export interface CustomDomainSchema {
+  /**
+   * Primary key (nanoid)
+   */
+  id: string
+  /**
+   * ID of the organization
+   */
+  orgId: string
+  /**
+   * The custom domain
+   */
+  domain: string
+  /**
+   * The DNS target for the custom domain
+   */
+  dnsTarget: string
+  /**
+   * Whether the DNS has been verified
+   */
+  dnsVerified: boolean
+  /**
+   * Timestamp of last DNS verification
+   */
+  lastVerifiedAt?: number
+  /**
+   * Timestamp of creation
+   */
+  createdAt: number
+  /**
+   * Timestamp of last update
+   */
+  updatedAt: number
+}
+
+export class CustomDomainModel implements CustomDomainSchema {
+  id: string
+  orgId: string
+  domain: string
+  dnsTarget: string
+  dnsVerified: boolean
+  lastVerifiedAt?: number
+  createdAt: number
+  updatedAt: number
+
+  static createSchema(input: Partial<CustomDomainSchema> = {}): CustomDomainSchema {
+    const id = input.id ?? nanoid()
+    const result: CustomDomainSchema = {
+      id,
+      orgId: input.orgId || '',
+      domain: input.domain || '',
+      dnsTarget: input.dnsTarget || '',
+      dnsVerified: input.dnsVerified ?? false,
+      createdAt: input.createdAt ?? Date.now(),
+      updatedAt: input.updatedAt ?? Date.now(),
+    }
+    if (typeof input.lastVerifiedAt === 'number') {
+      result.lastVerifiedAt = input.lastVerifiedAt
+    }
+    return result
+  }
+
+  constructor(state?: Partial<CustomDomainSchema>) {
+    const init = CustomDomainModel.createSchema(state)
+    this.id = init.id
+    this.orgId = init.orgId
+    this.domain = init.domain
+    this.dnsTarget = init.dnsTarget
+    this.dnsVerified = init.dnsVerified
+    this.lastVerifiedAt = init.lastVerifiedAt
+    this.createdAt = init.createdAt
+    this.updatedAt = init.updatedAt
+  }
+
+  toJSON(): CustomDomainSchema {
+    const result: CustomDomainSchema = {
+      id: this.id,
+      orgId: this.orgId,
+      domain: this.domain,
+      dnsTarget: this.dnsTarget,
+      dnsVerified: this.dnsVerified,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    }
+    if (typeof this.lastVerifiedAt === 'number') {
+      result.lastVerifiedAt = this.lastVerifiedAt
+    }
+    return result
+  }
+
+  validate(): FieldValidationMessage[] {
+    const result: FieldValidationMessage[] = []
+    if (!this.domain) {
+      result.push({
+        field: 'domain',
+        message: 'Domain must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    if (!this.orgId) {
+      result.push({
+        field: 'orgId',
+        message: 'Org ID must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    if (!this.dnsTarget) {
+      result.push({
+        field: 'dnsTarget',
+        message: 'DNS target must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    return result
+  }
+}

package/src/models/store/Deployment.ts

@@ -0,0 +1,173 @@
+import type { FieldValidationMessage } from '../../exceptions/validation_error.js'
+import { nanoid } from '../../nanoid.js'
+
+/**
+ * Status of the deployment
+ */
+export enum DeploymentStatus {
+  /**
+   * Deployment is pending
+   */
+  Pending = 0,
+  /**
+   * Deployment is active
+   */
+  Active = 1,
+  /**
+   * Deployment is inactive
+   */
+  Inactive = 2,
+  /**
+   * Deployment has failed
+   */
+  Failed = 3,
+}
+
+export interface DeploymentSchema {
+  /**
+   * Primary key (nanoid)
+   */
+  id: string
+  /**
+   * ID of the organization
+   */
+  orgId: string
+  /**
+   * The file ID representing the API
+   */
+  apiId: string
+  /**
+   * The version of the deployment (e.g., 'v1', 'v2')
+   */
+  deploymentVersion: string
+  /**
+   * The semantic version of the deployed API model (e.g., '1.0.1')
+   */
+  apiModelVersion: string
+  /**
+   * Status of the deployment
+   */
+  status: DeploymentStatus
+  /**
+   * Optional custom path for staging (e.g., '/dev')
+   */
+  stagingPath?: string
+  /**
+   * Reference to the optimized model in MongoDB
+   */
+  mongoModelId?: string
+  /**
+   * Timestamp of creation
+   */
+  createdAt: number
+  /**
+   * Timestamp of last update
+   */
+  updatedAt: number
+}
+
+export class Deployment implements DeploymentSchema {
+  id: string
+  orgId: string
+  apiId: string
+  deploymentVersion: string
+  apiModelVersion: string
+  status: DeploymentStatus
+  stagingPath?: string
+  mongoModelId?: string
+  createdAt: number
+  updatedAt: number
+
+  static createSchema(input: Partial<DeploymentSchema> = {}): DeploymentSchema {
+    const id = input.id ?? nanoid()
+    const result: DeploymentSchema = {
+      id,
+      orgId: input.orgId || '',
+      apiId: input.apiId || '',
+      deploymentVersion: input.deploymentVersion || 'v0',
+      apiModelVersion: input.apiModelVersion || '0.0.0',
+      status: input.status ?? DeploymentStatus.Pending,
+      createdAt: input.createdAt ?? Date.now(),
+      updatedAt: input.updatedAt ?? Date.now(),
+    }
+    if (input.stagingPath) {
+      result.stagingPath = input.stagingPath
+    }
+    if (input.mongoModelId) {
+      result.mongoModelId = input.mongoModelId
+    }
+    return result
+  }
+
+  constructor(state?: Partial<DeploymentSchema>) {
+    const init = Deployment.createSchema(state)
+    this.id = init.id
+    this.orgId = init.orgId
+    this.apiId = init.apiId
+    this.deploymentVersion = init.deploymentVersion
+    this.apiModelVersion = init.apiModelVersion
+    this.status = init.status
+    if (init.stagingPath) {
+      this.stagingPath = init.stagingPath
+    }
+    if (init.mongoModelId) {
+      this.mongoModelId = init.mongoModelId
+    }
+    this.createdAt = init.createdAt
+    this.updatedAt = init.updatedAt
+  }
+
+  toJSON(): DeploymentSchema {
+    const result: DeploymentSchema = {
+      id: this.id,
+      orgId: this.orgId,
+      apiId: this.apiId,
+      deploymentVersion: this.deploymentVersion,
+      apiModelVersion: this.apiModelVersion,
+      status: this.status,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    }
+    if (this.stagingPath) {
+      result.stagingPath = this.stagingPath
+    }
+    if (this.mongoModelId) {
+      result.mongoModelId = this.mongoModelId
+    }
+    return result
+  }
+
+  validate(): FieldValidationMessage[] {
+    const result: FieldValidationMessage[] = []
+
+    if (this.orgId === '') {
+      result.push({
+        field: 'orgId',
+        message: 'Org ID must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    if (this.apiId === '') {
+      result.push({
+        field: 'apiId',
+        message: 'API ID must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    if (this.deploymentVersion === '') {
+      result.push({
+        field: 'deploymentVersion',
+        message: 'Deployment version must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    if (this.apiModelVersion === '') {
+      result.push({
+        field: 'apiModelVersion',
+        message: 'API model version must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    return result
+  }
+}

package/src/models/store/DeploymentCustomDomain.ts

@@ -0,0 +1,120 @@
+import type { FieldValidationMessage } from '../../exceptions/validation_error.js'
+import { nanoid } from '../../nanoid.js'
+
+export enum SslStatus {
+  Initializing = 0,
+  PendingDns = 1,
+  Issuing = 2,
+  Active = 3,
+  Error = 4,
+}
+
+export interface DeploymentCustomDomainSchema {
+  /**
+   * Primary key (nanoid)
+   */
+  id: string
+  /**
+   * ID of the deployment
+   */
+  deploymentId: string
+  /**
+   * ID of the custom domain
+   */
+  customDomainId: string
+  /**
+   * The base path for the deployment
+   */
+  basePath: string
+  /**
+   * Status of the SSL certificate
+   */
+  sslStatus: SslStatus
+  /**
+   * Timestamp of creation
+   */
+  createdAt: number
+  /**
+   * Timestamp of last update
+   */
+  updatedAt: number
+}
+
+export class DeploymentCustomDomainModel implements DeploymentCustomDomainSchema {
+  id: string
+  deploymentId: string
+  customDomainId: string
+  basePath: string
+  sslStatus: SslStatus
+  createdAt: number
+  updatedAt: number
+
+  static createSchema(input: Partial<DeploymentCustomDomainSchema> = {}): DeploymentCustomDomainSchema {
+    const id = input.id ?? nanoid()
+    return {
+      id,
+      deploymentId: input.deploymentId || '',
+      customDomainId: input.customDomainId || '',
+      basePath: input.basePath ?? '/',
+      sslStatus: input.sslStatus ?? SslStatus.PendingDns,
+      createdAt: input.createdAt ?? Date.now(),
+      updatedAt: input.updatedAt ?? Date.now(),
+    }
+  }
+
+  constructor(state?: Partial<DeploymentCustomDomainSchema>) {
+    const init = DeploymentCustomDomainModel.createSchema(state)
+    this.id = init.id
+    this.deploymentId = init.deploymentId
+    this.customDomainId = init.customDomainId
+    this.basePath = init.basePath
+    this.sslStatus = init.sslStatus
+    this.createdAt = init.createdAt
+    this.updatedAt = init.updatedAt
+  }
+
+  toJSON(): DeploymentCustomDomainSchema {
+    return {
+      id: this.id,
+      deploymentId: this.deploymentId,
+      customDomainId: this.customDomainId,
+      basePath: this.basePath,
+      sslStatus: this.sslStatus,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    }
+  }
+
+  validate(): FieldValidationMessage[] {
+    const result: FieldValidationMessage[] = []
+
+    if (this.basePath === '') {
+      result.push({
+        field: 'basePath',
+        message: 'Base path must not be empty',
+        rule: 'notEmpty',
+      })
+    } else if (!this.basePath.startsWith('/')) {
+      result.push({
+        field: 'basePath',
+        message: 'Base path must start with a slash',
+        rule: 'startsWithSlash',
+      })
+    }
+    if (!this.deploymentId) {
+      result.push({
+        field: 'deploymentId',
+        message: 'Deployment ID must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    if (!this.customDomainId) {
+      result.push({
+        field: 'customDomainId',
+        message: 'Custom domain ID must not be empty',
+        rule: 'notEmpty',
+      })
+    }
+    return result
+  }
+}

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,134 @@
+import { test } from '@japa/runner'
+import { Deployment, 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.id)
+    assert.equal(result.orgId, '')
+    assert.equal(result.apiId, '')
+    assert.equal(result.deploymentVersion, 'v0')
+    assert.equal(result.apiModelVersion, '0.0.0')
+    assert.equal(result.status, DeploymentStatus.Pending)
+    assert.isUndefined(result.stagingPath)
+    assert.isUndefined(result.mongoModelId)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      stagingPath: '/stage',
+      mongoModelId: 'mongo-1',
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = Deployment.createSchema(init)
+    assert.equal(result.id, 'test-id')
+    assert.equal(result.orgId, 'org-1')
+    assert.equal(result.apiId, 'api-1')
+    assert.equal(result.deploymentVersion, 'v1')
+    assert.equal(result.apiModelVersion, '1.0.0')
+    assert.equal(result.status, DeploymentStatus.Active)
+    assert.equal(result.stagingPath, '/stage')
+    assert.equal(result.mongoModelId, 'mongo-1')
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const deployment = new Deployment()
+    assert.isString(deployment.id)
+    assert.equal(deployment.orgId, '')
+    assert.equal(deployment.apiId, '')
+    assert.equal(deployment.deploymentVersion, 'v0')
+    assert.equal(deployment.apiModelVersion, '0.0.0')
+    assert.equal(deployment.status, DeploymentStatus.Pending)
+    assert.isUndefined(deployment.stagingPath)
+    assert.isUndefined(deployment.mongoModelId)
+    assert.isNumber(deployment.createdAt)
+    assert.isNumber(deployment.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      orgId: 'org-1',
+      apiId: 'api-1',
+      stagingPath: '/stage',
+    }
+    const deployment = new Deployment(init)
+    assert.equal(deployment.orgId, 'org-1')
+    assert.equal(deployment.apiId, 'api-1')
+    assert.equal(deployment.stagingPath, '/stage')
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      stagingPath: '/stage',
+      mongoModelId: 'mongo-1',
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const deployment = new Deployment(init)
+    const result = deployment.toJSON()
+    assert.deepEqual(result, {
+      id: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      stagingPath: '/stage',
+      mongoModelId: 'mongo-1',
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty fields', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: '',
+      apiId: '',
+    })
+    deployment.deploymentVersion = ''
+    deployment.apiModelVersion = ''
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 4)
+    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: 'deploymentVersion',
+      message: 'Deployment version must not be empty',
+      rule: 'notEmpty',
+    })
+    assert.deepEqual(errors[3], {
+      field: 'apiModelVersion',
+      message: 'API model version must not be empty',
+      rule: 'notEmpty',
+    })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 0)
+  })
+})