@de./sdk 1.0.4 → 1.0.5

package/src/allend/Pipelines/index.ts

@@ -0,0 +1,131 @@
+import type { Env, Platform } from '../../types'
+import type { AccessOptions } from '../../types/access'
+import type {
+	PipelineListValidation,
+	PipelineRetrieveValidation,
+	PipelineDeployValidation,
+	PipelineValidateValidation,
+	PipelineSimulateValidation,
+	PipelineSetStatusValidation
+} from '@de./types'
+import AccessManager from '../Access'
+import { qs, type Res } from '../../utils'
+import { PipelinesWorkers } from './workers'
+import { PipelinesMonitor } from './monitor'
+import { PipelinesQueries } from './queries'
+import { PipelinesWebhooks } from './webhooks'
+import { PipelinesTemplates } from './templates'
+import { PipelinesAnalytics } from './analytics'
+import { PipelinesExecutions } from './executions'
+import { PipelinesEscalations } from './escalations'
+import { PipelinesInterventions } from './interventions'
+
+// ─── Config ───────────────────────────────────────────────────────────────────
+
+export type PipelinesConfig = {
+	context: string
+	accessToken: string
+	env?: Env
+	platform?: Platform
+	remoteOrigin?: string
+	version?: number
+}
+
+// ─── Pipelines ────────────────────────────────────────────────────────────────
+
+export default class Pipelines extends AccessManager {
+	readonly monitor:       PipelinesMonitor
+	readonly queries:       PipelinesQueries
+	readonly webhooks:      PipelinesWebhooks
+	readonly templates:     PipelinesTemplates
+	readonly analytics:     PipelinesAnalytics
+	readonly executions:    PipelinesExecutions
+	readonly escalations:   PipelinesEscalations
+	readonly interventions: PipelinesInterventions
+	readonly workers:       PipelinesWorkers
+
+	constructor( config: PipelinesConfig ){
+		if( !config )              throw new Error('Undefined config')
+		if( !config.context )      throw new Error('Undefined context')
+		if( !config.accessToken )  throw new Error('Undefined accessToken')
+
+		const access: AccessOptions = {
+			context:      config.context,
+			accessToken:  config.accessToken,
+			env:          config.env      || 'dev',
+			platform:     config.platform || 'proxy',
+			remoteOrigin: config.remoteOrigin,
+			version:      config.version
+		}
+
+		super( access, 'API' )
+
+		this.monitor       = new PipelinesMonitor( this )
+		this.queries       = new PipelinesQueries( this )
+		this.webhooks      = new PipelinesWebhooks( this )
+		this.templates     = new PipelinesTemplates( this )
+		this.analytics     = new PipelinesAnalytics( this )
+		this.executions    = new PipelinesExecutions( this )
+		this.escalations   = new PipelinesEscalations( this )
+		this.interventions = new PipelinesInterventions( this )
+		this.workers       = new PipelinesWorkers( this )
+	}
+
+	// ── Pipeline definitions ──────────────────────────────────────────────────
+
+	async list( querystring?: PipelineListValidation['querystring'] ): Promise<PipelineListValidation['response']> {
+		const { error, message, data } = await this.request<Res<PipelineListValidation['response']>>({
+			url: `/pipelines${qs( querystring )}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async get( id: string ): Promise<PipelineRetrieveValidation['response']> {
+		const { error, message, data } = await this.request<Res<PipelineRetrieveValidation['response']>>({
+			url: `/pipelines/${id}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async deploy( id: string, body?: PipelineDeployValidation['body'] ): Promise<PipelineDeployValidation['response']> {
+		const { error, message, data } = await this.request<Res<PipelineDeployValidation['response']>>({
+			url: `/pipelines/${id}/deploy`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async validate( id: string ): Promise<PipelineValidateValidation['response']> {
+		const { error, message, data } = await this.request<Res<PipelineValidateValidation['response']>>({
+			url: `/pipelines/${id}/validate`,
+			method: 'POST'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async simulate( id: string, body?: PipelineSimulateValidation['body'] ): Promise<PipelineSimulateValidation['response']> {
+		const { error, message, data } = await this.request<Res<PipelineSimulateValidation['response']>>({
+			url: `/pipelines/${id}/simulate`,
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async setStatus( id: string, status: string ): Promise<PipelineSetStatusValidation['response']> {
+		const { error, message, data } = await this.request<Res<PipelineSetStatusValidation['response']>>({
+			url: `/pipelines/${id}/status/${status}`,
+			method: 'PATCH'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Pipelines/interventions.ts

@@ -0,0 +1,31 @@
+import type {
+	PipelineInterventionStageValidation,
+	PipelineInterventionExecutionValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Interventions ────────────────────────────────────────────────────────────
+
+export class PipelinesInterventions {
+  constructor( private http: Http ){}
+
+  async stage( executionId: string, stageId: string, body?: PipelineInterventionStageValidation['body'] ): Promise<PipelineInterventionStageValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineInterventionStageValidation['response']>>({
+      url: `/pipelines/interventions/stage/${executionId}/${stageId}`,
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async execution( executionId: string, body?: PipelineInterventionExecutionValidation['body'] ): Promise<PipelineInterventionExecutionValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineInterventionExecutionValidation['response']>>({
+      url: `/pipelines/interventions/execution/${executionId}`,
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+}

package/src/allend/Pipelines/monitor.ts

@@ -0,0 +1,39 @@
+import type {
+	PipelineMonitorListValidation,
+	PipelineMonitorGetValidation,
+	PipelineMonitorOverviewValidation
+} from '@de./types'
+import { qs, type Http, type Res } from '../../utils'
+
+// ─── Monitor ──────────────────────────────────────────────────────────────────
+
+export class PipelinesMonitor {
+  constructor( private http: Http ){}
+
+  async list( querystring?: PipelineMonitorListValidation['querystring'] ): Promise<PipelineMonitorListValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineMonitorListValidation['response']>>({
+      url: `/pipelines/monitor${qs( querystring )}`,
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async get( executionId: string ): Promise<PipelineMonitorGetValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineMonitorGetValidation['response']>>({
+      url: `/pipelines/monitor/${executionId}`,
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async overview(): Promise<PipelineMonitorOverviewValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineMonitorOverviewValidation['response']>>({
+      url: '/pipelines/monitor/overview',
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+}

package/src/allend/Pipelines/queries.ts

@@ -0,0 +1,31 @@
+import type {
+	PipelineQueriesSearchValidation,
+	PipelineQueriesRecommendValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Queries ──────────────────────────────────────────────────────────────────
+
+export class PipelinesQueries {
+  constructor( private http: Http ){}
+
+  async search( body: PipelineQueriesSearchValidation['body'] ): Promise<PipelineQueriesSearchValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineQueriesSearchValidation['response']>>({
+      url: '/pipelines/queries/search',
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async recommend( body: PipelineQueriesRecommendValidation['body'] ): Promise<PipelineQueriesRecommendValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineQueriesRecommendValidation['response']>>({
+      url: '/pipelines/queries/recommend',
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+}

package/src/allend/Pipelines/templates.ts

@@ -0,0 +1,59 @@
+import type {
+	PipelineTemplateCreateValidation,
+	PipelineTemplateGetValidation,
+	PipelineTemplateListValidation,
+	PipelineTemplateUpdateValidation
+} from '@de./types'
+import { qs, type Http, type Res } from '../../utils'
+
+// ─── Templates ────────────────────────────────────────────────────────────────
+
+export class PipelinesTemplates {
+  constructor( private http: Http ){}
+
+  async create( body: PipelineTemplateCreateValidation['body'] ): Promise<PipelineTemplateCreateValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineTemplateCreateValidation['response']>>({
+      url: '/pipelines/templates',
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async list( querystring?: PipelineTemplateListValidation['querystring'] ): Promise<PipelineTemplateListValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineTemplateListValidation['response']>>({
+      url: `/pipelines/templates${qs( querystring )}`,
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async get( id: string ): Promise<PipelineTemplateGetValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineTemplateGetValidation['response']>>({
+      url: `/pipelines/templates/${id}`,
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async update( id: string, body: PipelineTemplateUpdateValidation['body'] ): Promise<PipelineTemplateUpdateValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineTemplateUpdateValidation['response']>>({
+      url: `/pipelines/templates/${id}`,
+      method: 'PATCH',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async delete( id: string ): Promise<void> {
+    const { error, message } = await this.http.request<Res>({
+      url: `/pipelines/templates/${id}`,
+      method: 'DELETE'
+    })
+    if( error ) throw new Error( message )
+  }
+}

package/src/allend/Pipelines/webhooks.ts

@@ -0,0 +1,38 @@
+import type {
+	PipelineWebhookProcessValidation,
+	PipelineWebhookRegisterValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Webhooks ─────────────────────────────────────────────────────────────────
+
+export class PipelinesWebhooks {
+  constructor( private http: Http ){}
+
+  async process( body: PipelineWebhookProcessValidation['body'] ): Promise<PipelineWebhookProcessValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineWebhookProcessValidation['response']>>({
+      url: '/pipelines/webhooks',
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async attach( id: string, body: PipelineWebhookRegisterValidation['body'] ): Promise<void> {
+    const { error, message } = await this.http.request<Res>({
+      url: `/pipelines/deployed/${id}/webhook`,
+      method: 'POST',
+      body
+    })
+    if( error ) throw new Error( message )
+  }
+
+  async detach( id: string ): Promise<void> {
+    const { error, message } = await this.http.request<Res>({
+      url: `/pipelines/deployed/${id}/webhook`,
+      method: 'DELETE'
+    })
+    if( error ) throw new Error( message )
+  }
+}

package/src/allend/Pipelines/workers.ts

@@ -0,0 +1,55 @@
+import type {
+	PipelineWorkerInitializeValidation,
+	PipelineWorkerStatsValidation,
+	PipelineWorkerStatsByNameValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Workers ──────────────────────────────────────────────────────────────────
+
+export class PipelinesWorkers {
+  constructor( private http: Http ){}
+
+  async initialize(): Promise<PipelineWorkerInitializeValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineWorkerInitializeValidation['response']>>({
+      url: '/pipelines/workers/initialize',
+      method: 'POST'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async start(): Promise<void> {
+    const { error, message } = await this.http.request<Res>({
+      url: '/pipelines/workers/start',
+      method: 'POST'
+    })
+    if( error ) throw new Error( message )
+  }
+
+  async stop(): Promise<void> {
+    const { error, message } = await this.http.request<Res>({
+      url: '/pipelines/workers/stop',
+      method: 'POST'
+    })
+    if( error ) throw new Error( message )
+  }
+
+  async stats(): Promise<PipelineWorkerStatsValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineWorkerStatsValidation['response']>>({
+      url: '/pipelines/workers/stats',
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+
+  async statsByName( name: string ): Promise<PipelineWorkerStatsByNameValidation['response']> {
+    const { error, message, data } = await this.http.request<Res<PipelineWorkerStatsByNameValidation['response']>>({
+      url: `/pipelines/workers/stats/${name}`,
+      method: 'GET'
+    })
+    if( error ) throw new Error( message )
+    return data
+  }
+}

package/src/allend/Queries/capacity.ts

@@ -0,0 +1,61 @@
+import type {
+	QueryCapacityValidation,
+	QueryBatchCapacityValidation,
+	QueryAllCapacitiesValidation,
+	QueryCapacityInvalidateCacheValidation,
+	QueryCapacityCacheStatsValidation
+} from '@de./types'
+import { type Http, type Res, qs } from '../../utils'
+
+// ─── Capacity ─────────────────────────────────────────────────────────────────
+
+export class QueriesCapacity {
+	constructor( private http: Http ){}
+
+	async query( body: QueryCapacityValidation['body'] ): Promise<QueryCapacityValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryCapacityValidation['response']>>({
+			url: '/queries/capacity/query',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async batchQuery( body: QueryBatchCapacityValidation['body'] ): Promise<QueryBatchCapacityValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryBatchCapacityValidation['response']>>({
+			url: '/queries/capacity/query/batch',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async getAll( lsp: string, serviceId: string ): Promise<QueryAllCapacitiesValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryAllCapacitiesValidation['response']>>({
+			url: `/queries/capacity/${lsp}/${serviceId}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async invalidateCache( lsp: string, serviceId: string, querystring?: QueryCapacityInvalidateCacheValidation['querystring'] ): Promise<QueryCapacityInvalidateCacheValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryCapacityInvalidateCacheValidation['response']>>({
+			url: `/queries/capacity/cache/${lsp}/${serviceId}${qs( querystring )}`,
+			method: 'DELETE'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async cacheStats(): Promise<QueryCapacityCacheStatsValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryCapacityCacheStatsValidation['response']>>({
+			url: '/queries/capacity/cache/stats',
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Queries/discovery.ts

@@ -0,0 +1,63 @@
+import type {
+	QueryDiscoverValidation,
+	QueryAdvancedDiscoverValidation,
+	QueryFindAvailableValidation,
+	QueryCountServicesValidation,
+	QueryGetServiceValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Discovery ────────────────────────────────────────────────────────────────
+
+export class QueriesDiscovery {
+	constructor( private http: Http ){}
+
+	async discover( body: QueryDiscoverValidation['body'] ): Promise<QueryDiscoverValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryDiscoverValidation['response']>>({
+			url: '/queries/discovery/discover',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async advancedDiscover( body: QueryAdvancedDiscoverValidation['body'] ): Promise<QueryAdvancedDiscoverValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryAdvancedDiscoverValidation['response']>>({
+			url: '/queries/discovery/discover/advanced',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async findAvailable( body: QueryFindAvailableValidation['body'] ): Promise<QueryFindAvailableValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryFindAvailableValidation['response']>>({
+			url: '/queries/discovery/available',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async count( body: QueryCountServicesValidation['body'] ): Promise<QueryCountServicesValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryCountServicesValidation['response']>>({
+			url: '/queries/discovery/count',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async get( compositeId: string ): Promise<QueryGetServiceValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryGetServiceValidation['response']>>({
+			url: `/queries/discovery/${compositeId}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Queries/index.ts

@@ -0,0 +1,52 @@
+import type { Env, Platform } from '../../types'
+import type { AccessOptions } from '../../types/access'
+import AccessManager from '../Access'
+import { QueriesDiscovery } from './discovery'
+import { QueriesMatching } from './matching'
+import { QueriesCapacity } from './capacity'
+import { QueriesPerformance } from './performance'
+import { QueriesPricing } from './pricing'
+
+// ─── Config ───────────────────────────────────────────────────────────────────
+
+export type QueriesConfig = {
+	context: string
+	accessToken: string
+	env?: Env
+	platform?: Platform
+	remoteOrigin?: string
+	version?: number
+}
+
+// ─── Queries ──────────────────────────────────────────────────────────────────
+
+export default class Queries extends AccessManager {
+	readonly discovery:   QueriesDiscovery
+	readonly matching:    QueriesMatching
+	readonly capacity:    QueriesCapacity
+	readonly performance: QueriesPerformance
+	readonly pricing:     QueriesPricing
+
+	constructor( config: QueriesConfig ){
+		if( !config )             throw new Error('Undefined config')
+		if( !config.context )     throw new Error('Undefined context')
+		if( !config.accessToken ) throw new Error('Undefined accessToken')
+
+		const access: AccessOptions = {
+			context:      config.context,
+			accessToken:  config.accessToken,
+			env:          config.env      || 'dev',
+			platform:     config.platform || 'proxy',
+			remoteOrigin: config.remoteOrigin,
+			version:      config.version
+		}
+
+		super( access, 'API' )
+
+		this.discovery   = new QueriesDiscovery( this )
+		this.matching    = new QueriesMatching( this )
+		this.capacity    = new QueriesCapacity( this )
+		this.performance = new QueriesPerformance( this )
+		this.pricing     = new QueriesPricing( this )
+	}
+}

package/src/allend/Queries/matching.ts

@@ -0,0 +1,18 @@
+import type { QueryMatchValidation } from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Matching ─────────────────────────────────────────────────────────────────
+
+export class QueriesMatching {
+	constructor( private http: Http ){}
+
+	async match( body: QueryMatchValidation['body'] ): Promise<QueryMatchValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryMatchValidation['response']>>({
+			url: '/queries/matching/match',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}

package/src/allend/Queries/performance.ts

@@ -0,0 +1,41 @@
+import type {
+	QuerySyncPerformanceValidation,
+	QueryBatchSyncPerformanceValidation,
+	QueryGetPerformanceValidation
+} from '@de./types'
+import { type Http, type Res } from '../../utils'
+
+// ─── Performance ──────────────────────────────────────────────────────────────
+
+export class QueriesPerformance {
+	constructor( private http: Http ){}
+
+	async sync( body: QuerySyncPerformanceValidation['body'] ): Promise<QuerySyncPerformanceValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QuerySyncPerformanceValidation['response']>>({
+			url: '/queries/performance/sync',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async batchSync( body: QueryBatchSyncPerformanceValidation['body'] ): Promise<QueryBatchSyncPerformanceValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryBatchSyncPerformanceValidation['response']>>({
+			url: '/queries/performance/sync/batch',
+			method: 'POST',
+			body
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+
+	async get( lsp: string, serviceId: string ): Promise<QueryGetPerformanceValidation['response']> {
+		const { error, message, data } = await this.http.request<Res<QueryGetPerformanceValidation['response']>>({
+			url: `/queries/performance/${lsp}/${serviceId}`,
+			method: 'GET'
+		})
+		if( error ) throw new Error( message )
+		return data
+	}
+}