@de./sdk 1.0.5 → 2.1.0

package/src/allend/OTPAuth/index.ts

@@ -1,37 +1,130 @@
-import type { HTTPRequestOptions, HTTPResponse } from '../../types'
-import type { AccessOptions } from '../../types/access'
+import type { AccessOptions, UserSession } from '../../types/access'
 import AccessManager from '../Access'
+import { qs, type Res } from '../../utils'
 
-type SigninBody = {
-  type?: 'CUSTOMER' | 'VENDOR' | 'ADMIN',
-  phone: string,
-  device?: string, // JSON string
-  country?: string // ISO 3166-1 alpha-2
+// ─────────────────────────────────────────────────────────────────────────────
+//
+// OTPAuth: sign a person in — de.auth routes.
+//
+// The whole flow is phone-and-OTP, in three steps:
+//
+//   signin( phone, device )  → sends the code, replies `{ next }`
+//   verify( phone, pvc )     → replies the session: ctoken + deviceId
+//   setAccount( … )          → only when `next` says the person is new
+//
+// This client used to POST `/v1/auth/otp`, which de.auth does not serve — the
+// single method it had could never succeed. Route shapes are taken from
+// de.auth/src/routes/{auth,user}/index.ts.
+//
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type SigninBody = {
+	phone: string
+	/** Device fingerprint — an object or its JSON string. */
+	device: string | Record<string, any>
+	/** ISO 3166-1 alpha-2. */
+	country?: string
+}
+
+export type SigninResult = {
+	/** What the caller must do next — verification, or account creation first. */
+	next: string
+	/**
+	 * The OTP itself, returned only when de.auth runs with
+	 * NODE_ENV=development. In every other environment the code arrives by SMS
+	 * and this is absent, which is what makes unattended sign-in a dev-only
+	 * capability rather than a hole.
+	 */
+	testVCode?: number
+}
+
+export type CreateAccountBody = {
+	phone: string
+	agreeTerms: boolean | string
+	firstName?: string
+	lastName?: string
+	photo?: string
+	type?: string
+	country?: string
+	newsletters?: boolean | string
+}
+
+export type VerifyResult = {
+	ctoken?: string
+	deviceId?: string
+	[ key: string ]: any
 }
-type SigninResponse = HTTPResponse<{ token: string }>
 
 export default class OTPAuth extends AccessManager {
-  constructor( access: AccessOptions ){
-    super( access, 'ASI' )
-  }
-
-  /**
-   * Request OTP
-   */
-  async getOTP( body: SigninBody ): Promise<SigninResponse> {
-    if( !body.phone )
-      throw new Error('<phone> argument required')
-    
-    const
-    options: HTTPRequestOptions = {
-      url: '/auth/otp',
-      method: 'POST',
-      body
-    },
-    response = await this.request<SigninResponse>( options )
-    if( response.error ) throw new Error( response.message )
-    
-    return response
-  }
-
-}
+	constructor( access: AccessOptions ){
+		super( access, 'ASI' )
+	}
+
+	// ── Sign-in ───────────────────────────────────────────────────────────────
+
+	/** Step 1 — sends the code. */
+	async signin( body: SigninBody ): Promise<Res<SigninResult>> {
+		if( !body.phone ) throw new Error('<phone> argument required')
+
+		return this.request<Res<SigninResult>>({ url: '/signin', method: 'POST', body })
+	}
+
+	/** Step 2 — exchanges the code for a session. */
+	async verify( body: { phone: string, pvc: number, new_phone?: string }): Promise<Res<VerifyResult>> {
+		return this.request<Res<VerifyResult>>({ url: '/verification', method: 'POST', body })
+	}
+
+	/** Step 1a — for a phone de.auth has never seen. */
+	async setAccount( body: CreateAccountBody ): Promise<Res<{ next: string }>> {
+		return this.request<Res<{ next: string }>>({ url: '/set-account', method: 'POST', body })
+	}
+
+	async resendSms( body: { phone: string }): Promise<Res<void>> {
+		return this.request<Res<void>>({ url: '/resend/sms', method: 'POST', body })
+	}
+
+	/** GET, with the scope in the querystring — not a POST. */
+	async signout( querystring?: { allDevices?: boolean | string }): Promise<Res<void>> {
+		return this.request<Res<void>>({ url: `/signout${qs( querystring )}`, method: 'GET' })
+	}
+
+	// ── The signed-in person ──────────────────────────────────────────────────
+
+	/**
+	 * Resolve the session to a user, and to a uid.
+	 *
+	 * `scope` is not optional in practice: without it de.auth falls back to the
+	 * calling service's configured scope and then fails its own response
+	 * validation. This is the same scope de.arch asks for.
+	 */
+	async active( session: UserSession, scope = 'name:photo:email:phone:timezone' ): Promise<Res<{ uid: string }>> {
+		return this.request<Res<{ uid: string }>>({
+			url: `/user/active${qs({ scope })}`,
+			method: 'GET',
+			headers: {
+				'de-auth-token':  session.token,
+				'de-auth-device': session.device
+			}
+		})
+	}
+
+	async retrieve( querystring?: { type?: string }): Promise<Res<{ user: any }>> {
+		return this.request<Res<{ user: any }>>({ url: `/user${qs( querystring )}`, method: 'GET' })
+	}
+
+	async search( querystring: Record<string, any> ): Promise<Res<any>> {
+		return this.request<Res<any>>({ url: `/user/search${qs( querystring )}`, method: 'GET' })
+	}
+
+	async updateProfile( body: Record<string, any> ): Promise<Res<any>> {
+		return this.request<Res<any>>({ url: '/user/profile', method: 'PATCH', body })
+	}
+
+	async updateSettings( body: Record<string, any> ): Promise<Res<any>> {
+		return this.request<Res<any>>({ url: '/user/settings', method: 'PATCH', body })
+	}
+
+	async remove( body: Record<string, any> ): Promise<Res<void>> {
+		return this.request<Res<void>>({ url: '/user', method: 'DELETE', body })
+	}
+}

package/src/allend/Pipelines/analytics.ts

@@ -2,7 +2,7 @@ import type {
 	PipelineAnalyticsOverviewValidation,
 	PipelineAnalyticsPipelineValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Analytics ────────────────────────────────────────────────────────────────
 
@@ -10,20 +10,16 @@ export class PipelinesAnalytics {
 	constructor( private http: Http ){}
 
 	async overview( querystring?: PipelineAnalyticsOverviewValidation['querystring'] ): Promise<PipelineAnalyticsOverviewValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<PipelineAnalyticsOverviewValidation['response']>>({
+		return await this.http.request<PipelineAnalyticsOverviewValidation['response']>({
 			url: `/pipelines/analytics/overview${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 
 	async pipeline( pid: string, querystring?: PipelineAnalyticsPipelineValidation['querystring'] ): Promise<PipelineAnalyticsPipelineValidation['response']> {
-		const { error, message, data } = await this.http.request<Res<PipelineAnalyticsPipelineValidation['response']>>({
+		return await this.http.request<PipelineAnalyticsPipelineValidation['response']>({
 			url: `/pipelines/analytics/pipeline/${pid}${qs( querystring )}`,
 			method: 'GET'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Pipelines/escalations.ts

@@ -2,7 +2,7 @@ import type {
 	PipelineEscalationListValidation,
 	PipelineEscalationResolveValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Escalations ──────────────────────────────────────────────────────────────
 
@@ -10,21 +10,17 @@ export class PipelinesEscalations {
   constructor( private http: Http ){}
 
   async list( querystring?: PipelineEscalationListValidation['querystring'] ): Promise<PipelineEscalationListValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineEscalationListValidation['response']>>({
+    return await this.http.request<PipelineEscalationListValidation['response']>({
       url: `/pipelines/escalations${qs( querystring )}`,
       method: 'GET'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async resolve( id: string, body?: PipelineEscalationResolveValidation['body'] ): Promise<PipelineEscalationResolveValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineEscalationResolveValidation['response']>>({
+    return await this.http.request<PipelineEscalationResolveValidation['response']>({
       url: `/pipelines/escalations/${id}/resolve`,
       method: 'POST',
       body
     })
-    if( error ) throw new Error( message )
-    return data
   }
 }

package/src/allend/Pipelines/executions.ts

@@ -5,7 +5,7 @@ import type {
 	PipelineExecutionActionValidation,
 	PipelineExecutionCancelValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Executions ───────────────────────────────────────────────────────────────
 
@@ -13,49 +13,39 @@ export class PipelinesExecutions {
   constructor( private http: Http ){}
 
   async create( body: PipelineExecutionCreateValidation['body'] ): Promise<PipelineExecutionCreateValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineExecutionCreateValidation['response']>>({
+    return await this.http.request<PipelineExecutionCreateValidation['response']>({
       url: '/pipelines/executions',
       method: 'POST',
       body
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async list( querystring?: PipelineExecutionListValidation['querystring'] ): Promise<PipelineExecutionListValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineExecutionListValidation['response']>>({
+    return await this.http.request<PipelineExecutionListValidation['response']>({
       url: `/pipelines/executions${qs( querystring )}`,
       method: 'GET'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async get( id: string ): Promise<PipelineExecutionGetValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineExecutionGetValidation['response']>>({
+    return await this.http.request<PipelineExecutionGetValidation['response']>({
       url: `/pipelines/executions/${id}`,
       method: 'GET'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async start( id: string ): Promise<PipelineExecutionActionValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineExecutionActionValidation['response']>>({
+    return await this.http.request<PipelineExecutionActionValidation['response']>({
       url: `/pipelines/executions/${id}/start`,
       method: 'POST'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async cancel( id: string, body: PipelineExecutionCancelValidation['body'] ): Promise<PipelineExecutionCancelValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineExecutionCancelValidation['response']>>({
+    return await this.http.request<PipelineExecutionCancelValidation['response']>({
       url: `/pipelines/executions/${id}/cancel`,
       method: 'POST',
       body
     })
-    if( error ) throw new Error( message )
-    return data
   }
 }

package/src/allend/Pipelines/index.ts

@@ -9,7 +9,7 @@ import type {
 	PipelineSetStatusValidation
 } from '@de./types'
 import AccessManager from '../Access'
-import { qs, type Res } from '../../utils'
+import { qs, type Res, type Data } from '../../utils'
 import { PipelinesWorkers } from './workers'
 import { PipelinesMonitor } from './monitor'
 import { PipelinesQueries } from './queries'
@@ -28,6 +28,10 @@ export type PipelinesConfig = {
 	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
 }
 
@@ -55,6 +59,8 @@ export default class Pipelines extends AccessManager {
 			env:          config.env      || 'dev',
 			platform:     config.platform || 'proxy',
 			remoteOrigin: config.remoteOrigin,
+			timeout:      config.timeout,
+			baseUrl:      config.baseUrl,
 			version:      config.version
 		}
 
@@ -74,58 +80,46 @@ export default class Pipelines extends AccessManager {
 	// ── Pipeline definitions ──────────────────────────────────────────────────
 
 	async list( querystring?: PipelineListValidation['querystring'] ): Promise<PipelineListValidation['response']> {
-		const { error, message, data } = await this.request<Res<PipelineListValidation['response']>>({
+		return await this.request<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']>>({
+		return await this.request<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']>>({
+		return await this.request<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']>>({
+		return await this.request<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']>>({
+		return await this.request<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']>>({
+		return await this.request<PipelineSetStatusValidation['response']>({
 			url: `/pipelines/${id}/status/${status}`,
 			method: 'PATCH'
 		})
-		if( error ) throw new Error( message )
-		return data
 	}
 }

package/src/allend/Pipelines/interventions.ts

@@ -2,7 +2,7 @@ import type {
 	PipelineInterventionStageValidation,
 	PipelineInterventionExecutionValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Interventions ────────────────────────────────────────────────────────────
 
@@ -10,22 +10,18 @@ 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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<PipelineInterventionExecutionValidation['response']>({
       url: `/pipelines/interventions/execution/${executionId}`,
       method: 'POST',
       body
     })
-    if( error ) throw new Error( message )
-    return data
   }
 }

package/src/allend/Pipelines/monitor.ts

@@ -3,7 +3,7 @@ import type {
 	PipelineMonitorGetValidation,
 	PipelineMonitorOverviewValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Monitor ──────────────────────────────────────────────────────────────────
 
@@ -11,29 +11,23 @@ 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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<PipelineMonitorOverviewValidation['response']>({
       url: '/pipelines/monitor/overview',
       method: 'GET'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 }

package/src/allend/Pipelines/queries.ts

@@ -2,7 +2,7 @@ import type {
 	PipelineQueriesSearchValidation,
 	PipelineQueriesRecommendValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Queries ──────────────────────────────────────────────────────────────────
 
@@ -10,22 +10,18 @@ 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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<PipelineQueriesRecommendValidation['response']>({
       url: '/pipelines/queries/recommend',
       method: 'POST',
       body
     })
-    if( error ) throw new Error( message )
-    return data
   }
 }

package/src/allend/Pipelines/templates.ts

@@ -4,7 +4,7 @@ import type {
 	PipelineTemplateListValidation,
 	PipelineTemplateUpdateValidation
 } from '@de./types'
-import { qs, type Http, type Res } from '../../utils'
+import { qs, type Http, type Res, type Data } from '../../utils'
 
 // ─── Templates ────────────────────────────────────────────────────────────────
 
@@ -12,41 +12,33 @@ 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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<PipelineTemplateUpdateValidation['response']>({
       url: `/pipelines/templates/${id}`,
       method: 'PATCH',
       body
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async delete( id: string ): Promise<void> {

package/src/allend/Pipelines/webhooks.ts

@@ -2,7 +2,7 @@ import type {
 	PipelineWebhookProcessValidation,
 	PipelineWebhookRegisterValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Webhooks ─────────────────────────────────────────────────────────────────
 
@@ -10,13 +10,11 @@ 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']>>({
+    return await this.http.request<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> {

package/src/allend/Pipelines/workers.ts

@@ -3,7 +3,7 @@ import type {
 	PipelineWorkerStatsValidation,
 	PipelineWorkerStatsByNameValidation
 } from '@de./types'
-import { type Http, type Res } from '../../utils'
+import { type Http, type Res, type Data } from '../../utils'
 
 // ─── Workers ──────────────────────────────────────────────────────────────────
 
@@ -11,12 +11,10 @@ export class PipelinesWorkers {
   constructor( private http: Http ){}
 
   async initialize(): Promise<PipelineWorkerInitializeValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineWorkerInitializeValidation['response']>>({
+    return await this.http.request<PipelineWorkerInitializeValidation['response']>({
       url: '/pipelines/workers/initialize',
       method: 'POST'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 
   async start(): Promise<void> {
@@ -36,20 +34,16 @@ export class PipelinesWorkers {
   }
 
   async stats(): Promise<PipelineWorkerStatsValidation['response']> {
-    const { error, message, data } = await this.http.request<Res<PipelineWorkerStatsValidation['response']>>({
+    return await this.http.request<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']>>({
+    return await this.http.request<PipelineWorkerStatsByNameValidation['response']>({
       url: `/pipelines/workers/stats/${name}`,
       method: 'GET'
     })
-    if( error ) throw new Error( message )
-    return data
   }
 }