@de./sdk 1.0.4 → 2.0.0

package/src/allend/Pipelines/executions.ts

@@ -0,0 +1,51 @@
+import type {
+	PipelineExecutionCreateValidation,
+	PipelineExecutionGetValidation,
+	PipelineExecutionListValidation,
+	PipelineExecutionActionValidation,
+	PipelineExecutionCancelValidation
+} from '@de./types'
+import { qs, type Http, type Res, type Data } from '../../utils'
+
+// ─── Executions ───────────────────────────────────────────────────────────────
+
+export class PipelinesExecutions {
+  constructor( private http: Http ){}
+
+  async create( body: PipelineExecutionCreateValidation['body'] ): Promise<PipelineExecutionCreateValidation['response']> {
+    return await this.http.request<PipelineExecutionCreateValidation['response']>({
+      url: '/pipelines/executions',
+      method: 'POST',
+      body
+    })
+  }
+
+  async list( querystring?: PipelineExecutionListValidation['querystring'] ): Promise<PipelineExecutionListValidation['response']> {
+    return await this.http.request<PipelineExecutionListValidation['response']>({
+      url: `/pipelines/executions${qs( querystring )}`,
+      method: 'GET'
+    })
+  }
+
+  async get( id: string ): Promise<PipelineExecutionGetValidation['response']> {
+    return await this.http.request<PipelineExecutionGetValidation['response']>({
+      url: `/pipelines/executions/${id}`,
+      method: 'GET'
+    })
+  }
+
+  async start( id: string ): Promise<PipelineExecutionActionValidation['response']> {
+    return await this.http.request<PipelineExecutionActionValidation['response']>({
+      url: `/pipelines/executions/${id}/start`,
+      method: 'POST'
+    })
+  }
+
+  async cancel( id: string, body: PipelineExecutionCancelValidation['body'] ): Promise<PipelineExecutionCancelValidation['response']> {
+    return await this.http.request<PipelineExecutionCancelValidation['response']>({
+      url: `/pipelines/executions/${id}/cancel`,
+      method: 'POST',
+      body
+    })
+  }
+}

package/src/allend/Pipelines/index.ts

@@ -0,0 +1,125 @@
+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, type Data } 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
+	/** Per-request deadline in ms. See `AccessOptions.timeout`. */
+	timeout?: number
+	/** Explicit service origin, overriding the env table. See `AccessOptions.baseUrl`. */
+	baseUrl?: 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,
+			timeout:      config.timeout,
+			baseUrl:      config.baseUrl,
+			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']> {
+		return await this.request<PipelineListValidation['response']>({
+			url: `/pipelines${qs( querystring )}`,
+			method: 'GET'
+		})
+	}
+
+	async get( id: string ): Promise<PipelineRetrieveValidation['response']> {
+		return await this.request<PipelineRetrieveValidation['response']>({
+			url: `/pipelines/${id}`,
+			method: 'GET'
+		})
+	}
+
+	async deploy( id: string, body?: PipelineDeployValidation['body'] ): Promise<PipelineDeployValidation['response']> {
+		return await this.request<PipelineDeployValidation['response']>({
+			url: `/pipelines/${id}/deploy`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async validate( id: string ): Promise<PipelineValidateValidation['response']> {
+		return await this.request<PipelineValidateValidation['response']>({
+			url: `/pipelines/${id}/validate`,
+			method: 'POST'
+		})
+	}
+
+	async simulate( id: string, body?: PipelineSimulateValidation['body'] ): Promise<PipelineSimulateValidation['response']> {
+		return await this.request<PipelineSimulateValidation['response']>({
+			url: `/pipelines/${id}/simulate`,
+			method: 'POST',
+			body
+		})
+	}
+
+	async setStatus( id: string, status: string ): Promise<PipelineSetStatusValidation['response']> {
+		return await this.request<PipelineSetStatusValidation['response']>({
+			url: `/pipelines/${id}/status/${status}`,
+			method: 'PATCH'
+		})
+	}
+}

package/src/allend/Pipelines/interventions.ts

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

package/src/allend/Pipelines/monitor.ts

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

package/src/allend/Pipelines/queries.ts

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

package/src/allend/Pipelines/templates.ts

@@ -0,0 +1,51 @@
+import type {
+	PipelineTemplateCreateValidation,
+	PipelineTemplateGetValidation,
+	PipelineTemplateListValidation,
+	PipelineTemplateUpdateValidation
+} from '@de./types'
+import { qs, type Http, type Res, type Data } from '../../utils'
+
+// ─── Templates ────────────────────────────────────────────────────────────────
+
+export class PipelinesTemplates {
+  constructor( private http: Http ){}
+
+  async create( body: PipelineTemplateCreateValidation['body'] ): Promise<PipelineTemplateCreateValidation['response']> {
+    return await this.http.request<PipelineTemplateCreateValidation['response']>({
+      url: '/pipelines/templates',
+      method: 'POST',
+      body
+    })
+  }
+
+  async list( querystring?: PipelineTemplateListValidation['querystring'] ): Promise<PipelineTemplateListValidation['response']> {
+    return await this.http.request<PipelineTemplateListValidation['response']>({
+      url: `/pipelines/templates${qs( querystring )}`,
+      method: 'GET'
+    })
+  }
+
+  async get( id: string ): Promise<PipelineTemplateGetValidation['response']> {
+    return await this.http.request<PipelineTemplateGetValidation['response']>({
+      url: `/pipelines/templates/${id}`,
+      method: 'GET'
+    })
+  }
+
+  async update( id: string, body: PipelineTemplateUpdateValidation['body'] ): Promise<PipelineTemplateUpdateValidation['response']> {
+    return await this.http.request<PipelineTemplateUpdateValidation['response']>({
+      url: `/pipelines/templates/${id}`,
+      method: 'PATCH',
+      body
+    })
+  }
+
+  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,36 @@
+import type {
+	PipelineWebhookProcessValidation,
+	PipelineWebhookRegisterValidation
+} from '@de./types'
+import { type Http, type Res, type Data } from '../../utils'
+
+// ─── Webhooks ─────────────────────────────────────────────────────────────────
+
+export class PipelinesWebhooks {
+  constructor( private http: Http ){}
+
+  async process( body: PipelineWebhookProcessValidation['body'] ): Promise<PipelineWebhookProcessValidation['response']> {
+    return await this.http.request<PipelineWebhookProcessValidation['response']>({
+      url: '/pipelines/webhooks',
+      method: 'POST',
+      body
+    })
+  }
+
+  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,49 @@
+import type {
+	PipelineWorkerInitializeValidation,
+	PipelineWorkerStatsValidation,
+	PipelineWorkerStatsByNameValidation
+} from '@de./types'
+import { type Http, type Res, type Data } from '../../utils'
+
+// ─── Workers ──────────────────────────────────────────────────────────────────
+
+export class PipelinesWorkers {
+  constructor( private http: Http ){}
+
+  async initialize(): Promise<PipelineWorkerInitializeValidation['response']> {
+    return await this.http.request<PipelineWorkerInitializeValidation['response']>({
+      url: '/pipelines/workers/initialize',
+      method: 'POST'
+    })
+  }
+
+  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']> {
+    return await this.http.request<PipelineWorkerStatsValidation['response']>({
+      url: '/pipelines/workers/stats',
+      method: 'GET'
+    })
+  }
+
+  async statsByName( name: string ): Promise<PipelineWorkerStatsByNameValidation['response']> {
+    return await this.http.request<PipelineWorkerStatsByNameValidation['response']>({
+      url: `/pipelines/workers/stats/${name}`,
+      method: 'GET'
+    })
+  }
+}

package/src/allend/Queries/capacity.ts

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

package/src/allend/Queries/discovery.ts

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

package/src/allend/Queries/index.ts

@@ -0,0 +1,58 @@
+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
+	/** Per-request deadline in ms. See `AccessOptions.timeout`. */
+	timeout?: number
+	/** Explicit service origin, overriding the env table. See `AccessOptions.baseUrl`. */
+	baseUrl?: 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,
+			timeout:      config.timeout,
+			baseUrl:      config.baseUrl,
+			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,16 @@
+import type { QueryMatchValidation } from '@de./types'
+import { type Http, type Res, type Data } from '../../utils'
+
+// ─── Matching ─────────────────────────────────────────────────────────────────
+
+export class QueriesMatching {
+	constructor( private http: Http ){}
+
+	async match( body: QueryMatchValidation['body'] ): Promise<QueryMatchValidation['response']> {
+		return await this.http.request<QueryMatchValidation['response']>({
+			url: '/queries/matching/match',
+			method: 'POST',
+			body
+		})
+	}
+}

package/src/allend/Queries/performance.ts

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