@api-client/core 0.19.22 → 0.19.24

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/modeling/actions/Action.spec.ts

@@ -2,10 +2,11 @@ import { test } from '@japa/runner'
 import { Action, AccessRule, RateLimitingConfiguration } from '../../../../src/modeling/index.js'
 import { type ActionSchema } from '../../../../src/modeling/actions/Action.js'
 import { type ExposedEntity } from '../../../../src/modeling/ExposedEntity.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('Action', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new Action({} as unknown as ExposedEntity)
+    const action = new Action(mockExposedEntity())
     assert.equal(action.kind, '')
     assert.deepEqual(action.accessRule, [])
     assert.isUndefined(action.rateLimiting)
@@ -17,7 +18,7 @@ test.group('Action', () => {
       accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
     }
-    const action = new Action({} as unknown as ExposedEntity, schema)
+    const action = new Action(mockExposedEntity(), schema)
     assert.equal(action.kind, 'read')
     assert.lengthOf(action.accessRule, 1)
     assert.instanceOf(action.accessRule[0], AccessRule)
@@ -26,7 +27,7 @@ test.group('Action', () => {
   }).tags(['@modeling', '@action'])
 
   test('serializes to JSON', ({ assert }) => {
-    const action = new Action({} as unknown as ExposedEntity, {
+    const action = new Action(mockExposedEntity(), {
       kind: 'write',
       accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
@@ -39,7 +40,7 @@ test.group('Action', () => {
   }).tags(['@modeling', '@action'])
 
   test('notifies change when kind changes', async ({ assert }) => {
-    const action = new Action({} as unknown as ExposedEntity, { kind: 'read' })
+    const action = new Action(mockExposedEntity(), { kind: 'read' })
     let notified = false
     action.addEventListener('change', () => {
       notified = true
@@ -53,19 +54,19 @@ test.group('Action', () => {
   }).tags(['@modeling', '@action', '@observed'])
 
   test('notifies change when accessRule array is replaced', async ({ assert }) => {
-    const action = new Action({} as unknown as ExposedEntity)
+    const action = new Action(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
-    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
+    action.accessRule = [new AccessRule(mockExposedEntity(), { type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@observed'])
 
   test('notifies change when rateLimiting is replaced', async ({ assert }) => {
-    const action = new Action({} as unknown as ExposedEntity)
+    const action = new Action(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
@@ -78,7 +79,7 @@ test.group('Action', () => {
 
   test('constructor copies accessRule array (immutability)', ({ assert }) => {
     const rules = [{ type: 'allowPublic' }]
-    const action = new Action({} as unknown as ExposedEntity, { kind: 'read', accessRule: rules })
+    const action = new Action(mockExposedEntity(), { kind: 'read', accessRule: rules })
 
     // Modify original array
     rules.push({ type: 'other' })
@@ -89,7 +90,7 @@ test.group('Action', () => {
   }).tags(['@modeling', '@action', '@immutability'])
 
   test('toJSON returns safe copy', ({ assert }) => {
-    const action = new Action({} as unknown as ExposedEntity, {
+    const action = new Action(mockExposedEntity(), {
       kind: 'read',
       accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
@@ -110,7 +111,8 @@ test.group('Action', () => {
 
   test('getAllRules() aggregates rules from action and parent', ({ assert }) => {
     const parent = {
-      getAllRules: () => [new AccessRule({ type: 'allowPublic' })],
+      getAllRules: () => [new AccessRule(mockExposedEntity(), { type: 'allowPublic' })],
+      notifyChange: () => {},
     } as unknown as ExposedEntity
 
     const action = new Action(parent, {
@@ -127,6 +129,7 @@ test.group('Action', () => {
     const parentLimiter = new RateLimitingConfiguration({ rules: [{ rate: 10, interval: 'second' }] })
     const parent = {
       getAllRateLimiters: () => [parentLimiter],
+      notifyChange: () => {},
     } as unknown as ExposedEntity
 
     const action = new Action(parent, {

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

@@ -1,16 +1,17 @@
 import { test } from '@japa/runner'
 import { CreateAction } from '../../../../src/modeling/actions/CreateAction.js'
 import { AccessRule } from '../../../../src/modeling/rules/index.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('CreateAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new CreateAction({} as any)
+    const action = new CreateAction(mockExposedEntity())
     assert.equal(action.kind, 'create')
     assert.isEmpty(action.accessRule) // Inherited from Action
   }).tags(['@modeling', '@action', '@create-action'])
 
   test('initializes with inherited values', ({ assert }) => {
-    const action = new CreateAction({} as any, {
+    const action = new CreateAction(mockExposedEntity(), {
       accessRule: [{ type: 'allowPublic' }],
     })
 
@@ -22,7 +23,7 @@ test.group('CreateAction', () => {
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const rules = [{ type: 'allowPublic' }]
 
-    const action = new CreateAction({} as any, {
+    const action = new CreateAction(mockExposedEntity(), {
       accessRule: rules,
     })
 
@@ -35,7 +36,7 @@ test.group('CreateAction', () => {
   }).tags(['@modeling', '@action', '@create-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new CreateAction({} as any, {
+    const action = new CreateAction(mockExposedEntity(), {
       accessRule: [{ type: 'allowPublic' }],
     })
 
@@ -51,14 +52,14 @@ test.group('CreateAction', () => {
   }).tags(['@modeling', '@action', '@create-action', '@serialization'])
 
   test('notifies change when inherited property changes', async ({ assert }) => {
-    const action = new CreateAction({} as any)
+    const action = new CreateAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
     // Modify inherited property
-    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
+    action.accessRule = [new AccessRule(mockExposedEntity(), { type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@create-action', '@observed'])

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { DeleteAction } from '../../../../src/modeling/actions/DeleteAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('DeleteAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new DeleteAction({} as any)
+    const action = new DeleteAction(mockExposedEntity())
     assert.equal(action.kind, 'delete')
     assert.equal(action.strategy, 'soft')
     assert.equal(action.retentionPeriod, 30)
@@ -11,7 +12,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action'])
 
   test('initializes with provided values', ({ assert }) => {
-    const action = new DeleteAction({} as any, {
+    const action = new DeleteAction(mockExposedEntity(), {
       strategy: 'hard',
       retentionPeriod: 0,
       accessRule: [{ type: 'allowPublic' }],
@@ -27,7 +28,7 @@ test.group('DeleteAction', () => {
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const rules = [{ type: 'allowPublic' }]
 
-    const action = new DeleteAction({} as any, {
+    const action = new DeleteAction(mockExposedEntity(), {
       accessRule: rules,
     })
 
@@ -40,7 +41,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new DeleteAction({} as any, {
+    const action = new DeleteAction(mockExposedEntity(), {
       strategy: 'hard',
       retentionPeriod: 0,
     })
@@ -53,7 +54,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action', '@serialization'])
 
   test('notifies change when strategy changes', async ({ assert }) => {
-    const action = new DeleteAction({} as any)
+    const action = new DeleteAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
@@ -65,7 +66,7 @@ test.group('DeleteAction', () => {
   }).tags(['@modeling', '@action', '@delete-action', '@observed'])
 
   test('notifies change when retentionPeriod changes', async ({ assert }) => {
-    const action = new DeleteAction({} as any)
+    const action = new DeleteAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('ListAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new ListAction({} as any)
+    const action = new ListAction(mockExposedEntity())
     assert.equal(action.kind, 'list')
     assert.isUndefined(action.cacheTtl)
     assert.isEmpty(action.accessRule) // Inherited from Action
@@ -12,7 +13,7 @@ test.group('ListAction', () => {
   test('initializes with provided values', ({ assert }) => {
     const cacheTtl = 100
 
-    const action = new ListAction({} as any, {
+    const action = new ListAction(mockExposedEntity(), {
       cacheTtl,
     })
 
@@ -20,7 +21,7 @@ test.group('ListAction', () => {
   }).tags(['@modeling', '@action', '@list-action'])
 
   test('toJSON returns safe copy', ({ assert }) => {
-    const action = new ListAction({} as any, {
+    const action = new ListAction(mockExposedEntity(), {
       cacheTtl: 100,
     })
 
@@ -33,7 +34,7 @@ test.group('ListAction', () => {
   }).tags(['@modeling', '@action', '@list-action', '@immutability'])
 
   test('notifies change when cacheTtl changes', async ({ assert }) => {
-    const action = new ListAction({} as any)
+    const action = new ListAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true

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

@@ -1,16 +1,17 @@
 import { test } from '@japa/runner'
 import { ReadAction } from '../../../../src/modeling/actions/ReadAction.js'
 import { AccessRule } from '../../../../src/modeling/rules/index.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('ReadAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new ReadAction({} as any)
+    const action = new ReadAction(mockExposedEntity())
     assert.equal(action.kind, 'read')
     assert.isEmpty(action.accessRule) // Inherited from Action
   }).tags(['@modeling', '@action', '@read-action'])
 
   test('initializes with inherited values', ({ assert }) => {
-    const action = new ReadAction({} as any, {
+    const action = new ReadAction(mockExposedEntity(), {
       accessRule: [{ type: 'allowPublic' }],
     })
 
@@ -22,7 +23,7 @@ test.group('ReadAction', () => {
   test('constructor copies arrays (immutability)', ({ assert }) => {
     const rules = [{ type: 'allowPublic' }]
 
-    const action = new ReadAction({} as any, {
+    const action = new ReadAction(mockExposedEntity(), {
       accessRule: rules,
     })
 
@@ -35,7 +36,7 @@ test.group('ReadAction', () => {
   }).tags(['@modeling', '@action', '@read-action', '@immutability'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new ReadAction({} as any, {
+    const action = new ReadAction(mockExposedEntity(), {
       accessRule: [{ type: 'allowPublic' }],
     })
 
@@ -51,26 +52,26 @@ test.group('ReadAction', () => {
   }).tags(['@modeling', '@action', '@read-action', '@serialization'])
 
   test('notifies change when inherited property changes', async ({ assert }) => {
-    const action = new ReadAction({} as any)
+    const action = new ReadAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
     // Modify inherited property
-    action.accessRule = [new AccessRule({ type: 'allowPublic' })]
+    action.accessRule = [new AccessRule(mockExposedEntity(), { type: 'allowPublic' })]
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@read-action', '@observed'])
 
   test('notifies change when accessRule value change', async ({ assert }) => {
-    const action = new ReadAction({} as any)
+    const action = new ReadAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true
     })
 
-    action.accessRule.push(new AccessRule({ type: 'allowPublic' }))
+    action.accessRule.push(new AccessRule(mockExposedEntity(), { type: 'allowPublic' }))
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@action', '@read-action', '@observed'])

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

@@ -1,9 +1,10 @@
 import { test } from '@japa/runner'
 import { SearchAction } from '../../../../src/modeling/actions/SearchAction.js'
+import { mockExposedEntity } from './helpers.js'
 
 test.group('SearchAction', () => {
   test('initializes with default values', ({ assert }) => {
-    const action = new SearchAction({} as any)
+    const action = new SearchAction(mockExposedEntity())
     assert.equal(action.kind, 'search')
     assert.isUndefined(action.maxAstDepth)
     assert.isEmpty(action.accessRule)
@@ -11,7 +12,7 @@ test.group('SearchAction', () => {
 
   test('initializes with provided values', ({ assert }) => {
     const maxAstDepth = 10
-    const action = new SearchAction({} as any, {
+    const action = new SearchAction(mockExposedEntity(), {
       maxAstDepth,
     })
 
@@ -20,7 +21,7 @@ test.group('SearchAction', () => {
   }).tags(['@modeling', '@action', '@search-action'])
 
   test('toJSON returns valid schema', ({ assert }) => {
-    const action = new SearchAction({} as any, {
+    const action = new SearchAction(mockExposedEntity(), {
       maxAstDepth: 10,
     })
 
@@ -34,7 +35,7 @@ test.group('SearchAction', () => {
   }).tags(['@modeling', '@action', '@search-action', '@serialization', '@immutability'])
 
   test('notifies change when maxAstDepth changes', async ({ assert }) => {
-    const action = new SearchAction({} as any)
+    const action = new SearchAction(mockExposedEntity())
     let notified = false
     action.addEventListener('change', () => {
       notified = true