@commercelayer/sdk 6.0.0-alfa.4 → 6.0.0-alfa.5

package/lib/esm/error.js

@@ -1,4 +1,4 @@
-import axios from 'axios';
+import { FetchError } from './fetch';
 var ErrorType;
 (function (ErrorType) {
     ErrorType["CLIENT"] = "client";
@@ -6,7 +6,7 @@ var ErrorType;
     ErrorType["RESPONSE"] = "response";
     ErrorType["CANCEL"] = "cancel";
     ErrorType["PARSE"] = "parse";
-    ErrorType["GENERIC"] = "generic";
+    ErrorType["TIMEOUT"] = "timeout"; // Timeout error
 })(ErrorType || (ErrorType = {}));
 class SdkError extends Error {
     static NAME = 'SdkError';
@@ -16,11 +16,10 @@ class SdkError extends Error {
     type;
     code;
     source;
-    request;
     constructor(error) {
         super(error.message);
-        this.name = SdkError.NAME; // this.constructor.name
-        this.type = error.type || ErrorType.GENERIC;
+        this.name = SdkError.NAME;
+        this.type = error.type || ErrorType.CLIENT;
     }
 }
 class ApiError extends SdkError {
@@ -33,42 +32,52 @@ class ApiError extends SdkError {
     statusText;
     constructor(error) {
         super({ ...error, type: ErrorType.RESPONSE });
-        this.name = ApiError.NAME; // this.constructor.name
+        this.name = ApiError.NAME;
     }
     first() {
         return (this.errors?.length > 0) ? this.errors[0] : undefined;
     }
 }
+const isRequestError = (error) => {
+    return error instanceof TypeError;
+};
+const isCancelError = (error) => {
+    return (error instanceof DOMException) && (error.name === 'AbortError');
+};
+const isTimeoutError = (error) => {
+    return (error instanceof DOMException) && (error.name === 'TimeoutError');
+};
 const handleError = (error) => {
     let sdkError = new SdkError({ message: error.message });
-    if (axios.isAxiosError(error)) {
-        if (error.response) {
-            // The request was made and the server responded with a status code that falls out of the range of 2xx
-            const apiError = new ApiError(sdkError);
-            apiError.type = ErrorType.RESPONSE;
-            apiError.status = error.response.status;
-            apiError.statusText = error.response.statusText;
-            apiError.code = String(apiError.status);
-            apiError.errors = error.response.data.errors;
-            if (!apiError.message && apiError.statusText)
-                apiError.message = apiError.statusText;
-            sdkError = apiError;
-        }
-        else if (error.request) {
-            // The request was made but no response was received
-            // `error.request` is an instance of XMLHttpRequest in the browser and an instance of http.ClientRequest in node.js
-            sdkError.type = ErrorType.REQUEST;
-            sdkError.request = error.request;
-        }
-        else {
-            // Something happened in setting up the request that triggered an Error
-            sdkError.type = ErrorType.CLIENT;
-        }
+    if (FetchError.isFetchError(error)) {
+        // console.log('********** FetchError')
+        const apiError = new ApiError(sdkError);
+        apiError.type = ErrorType.RESPONSE;
+        apiError.status = error.status;
+        apiError.statusText = error.statusText;
+        apiError.code = String(apiError.status);
+        apiError.errors = error.errors || [];
+        if (!apiError.message && apiError.statusText)
+            apiError.message = apiError.statusText;
+        sdkError = apiError;
+    }
+    else if (isRequestError(error)) {
+        // console.log('********** RequestError')
+        sdkError.type = ErrorType.REQUEST;
     }
-    else if (axios.isCancel(error))
+    else if (isCancelError(error)) {
+        // console.log('********** CancelError')
         sdkError.type = ErrorType.CANCEL;
-    else
+    }
+    else if (isTimeoutError(error)) {
+        // console.log('********** TimeoutError')
+        sdkError.type = ErrorType.TIMEOUT;
+    }
+    else {
+        // console.log('********** ClientError')
+        sdkError.type = ErrorType.CLIENT;
         sdkError.source = error;
+    }
     throw sdkError;
 };
 export { SdkError, ApiError, ErrorType, handleError };

package/lib/esm/fetch.d.ts

@@ -0,0 +1,13 @@
+import type { DocWithData } from 'jsonapi-typescript';
+import type { InterceptorManager } from './interceptor';
+export type FetchResponse = DocWithData;
+export type FetchOptions = RequestInit;
+export declare class FetchError extends Error {
+    #private;
+    static isFetchError: (error: any) => error is FetchError;
+    constructor(status: number, statusText: string, body?: any);
+    get errors(): any[] | undefined;
+    get status(): number;
+    get statusText(): string;
+}
+export declare const fetchURL: (url: URL, options: FetchOptions, interceptors?: InterceptorManager) => Promise<FetchResponse>;

package/lib/esm/fetch.js

@@ -0,0 +1,46 @@
+import Debug from './debug';
+const debug = Debug('fetch');
+export class FetchError extends Error {
+    static isFetchError = (error) => {
+        return error instanceof FetchError;
+    };
+    #errors;
+    #status;
+    #statusText;
+    constructor(status, statusText, body) {
+        super(statusText);
+        this.#status = status;
+        this.#statusText = statusText;
+        if (body)
+            this.#errors = body.errors;
+    }
+    get errors() { return this.#errors; }
+    get status() { return this.#status; }
+    get statusText() { return this.#statusText; }
+}
+export const fetchURL = async (url, options, interceptors) => {
+    debug('fetch: %s, %O', url, options || {});
+    if (interceptors?.request?.onSuccess)
+        ({ url, options } = await interceptors.request.onSuccess({ url, options }));
+    // const request: Request = new Request(url, options)
+    let response = await fetch(url, options);
+    if (response.ok) {
+        if (interceptors?.rawReader?.onSuccess)
+            await interceptors.rawReader.onSuccess(response);
+        if (interceptors?.response?.onSuccess)
+            response = await interceptors.response.onSuccess(response);
+    }
+    else {
+        if (interceptors?.rawReader?.onFailure)
+            await interceptors.rawReader.onFailure(response);
+    }
+    const responseBody = await response.json().catch(() => { });
+    if (!response.ok) {
+        let error = new FetchError(response.status, response.statusText, responseBody);
+        if (interceptors?.response?.onFailure)
+            error = await interceptors.response.onFailure(error);
+        if (error)
+            throw error;
+    }
+    return responseBody;
+};

package/lib/esm/interceptor.d.ts

@@ -1,25 +1,37 @@
-import type { AxiosError, AxiosInterceptorManager, AxiosRequestConfig, AxiosResponse, AxiosResponseHeaders, RawAxiosResponseHeaders } from 'axios';
+import type { FetchError, FetchOptions } from "./fetch";
+type InterceptorEventManager<S extends (RequestInterceptor | ResponseInterceptor), F extends (ErrorInterceptor | ResponseInterceptor)> = {
+    onSuccess?: S;
+    onFailure?: F;
+};
+type RequestEventManager = InterceptorEventManager<RequestInterceptor, ErrorInterceptor>;
+type ResponseEventManager = InterceptorEventManager<ResponseInterceptor, ErrorInterceptor>;
+type ErrorEventManager = InterceptorEventManager<ResponseInterceptor, ResponseInterceptor>;
 type InterceptorManager = {
-    request: AxiosInterceptorManager<AxiosRequestConfig>;
-    response: AxiosInterceptorManager<any>;
+    request?: RequestEventManager;
+    response?: ResponseEventManager;
+    rawReader?: ErrorEventManager;
+};
+type RequestObj = {
+    url: URL;
+    options: FetchOptions;
 };
-type RequestObj = AxiosRequestConfig;
 type RequestInterceptor = (request: RequestObj) => RequestObj | Promise<RequestObj>;
-type ResponseObj = AxiosResponse;
-type ResponseInterceptor = (response: ResponseObj) => ResponseObj;
+type ResponseObj = Response;
+type ResponseInterceptor = (response: ResponseObj) => ResponseObj | Promise<ResponseObj>;
 type ApiHeadersList = 'x-ratelimit-limit' | 'x-ratelimit-count' | 'x-ratelimit-period' | 'x-ratelimit-interval' | 'x-ratelimit-remaining';
 type ApiHeaders = {
     [key in ApiHeadersList]: string | number | boolean;
 };
-type HeadersObj = (AxiosResponseHeaders | RawAxiosResponseHeaders) & ApiHeaders;
-type ErrorObj = AxiosError;
-type ErrorInterceptor = (error: ErrorObj) => ErrorObj;
+type HeadersObj = Record<string, string> | ApiHeaders;
+type ErrorObj = FetchError;
+type ErrorInterceptor = (error: ErrorObj) => ErrorObj | Promise<ErrorObj>;
 type InterceptorType = 'request' | 'response';
 export type { InterceptorManager, RequestInterceptor, ResponseInterceptor, ErrorInterceptor, InterceptorType };
 export type { RequestObj, ResponseObj, ErrorObj, HeadersObj };
 type RawResponseReader = {
-    id: number | undefined;
-    rawResponse: ResponseObj | undefined;
-    headers: HeadersObj | undefined;
+    id?: number;
+    rawResponse?: any;
+    headers?: HeadersObj;
+    ok: boolean;
 };
 export type { RawResponseReader };

package/lib/esm/query.d.ts

@@ -14,4 +14,5 @@ type QueryParams = QueryParamsRetrieve | QueryParamsList;
 export type { QueryParamsRetrieve, QueryParamsList, QueryParams, QueryFilter };
 declare const isParamsList: (params: any) => params is QueryParamsList;
 declare const generateQueryStringParams: (params: QueryParamsRetrieve | QueryParamsList | undefined, res: string | ResourceType) => Record<string, string>;
-export { generateQueryStringParams, isParamsList };
+declare const generateSearchString: (params?: QueryParams, questionMark?: boolean) => string;
+export { generateQueryStringParams, isParamsList, generateSearchString };

package/lib/esm/query.js

@@ -1,5 +1,5 @@
-import Debug from './debug';
 import { ErrorType, SdkError } from "./error";
+import Debug from './debug';
 const debug = Debug('query');
 const arrayFilters = ['_any', '_all', '_in'];
 const objectFilters = ['_jcont'];
@@ -59,4 +59,9 @@ const generateQueryStringParams = (params, res) => {
     debug('query string params: %O', qp);
     return qp;
 };
-export { generateQueryStringParams, isParamsList };
+const generateSearchString = (params, questionMark = true) => {
+    if (!params || (Object.keys(params).length === 0))
+        return '';
+    return `${questionMark ? '?' : ''}${Object.entries(params).map(([key, val]) => `${key}=${String(val)}`).join('&')}`;
+};
+export { generateQueryStringParams, isParamsList, generateSearchString };

package/lib/esm/resource.d.ts

@@ -1,7 +1,6 @@
 import ApiClient, { type ApiClientInitConfig } from './client';
 import type { QueryParamsRetrieve, QueryParamsList, QueryFilter, QueryParams } from './query';
 import type { ResourceTypeLock } from './api';
-import type { InterceptorManager } from './interceptor';
 type ResourceNull = {
     id: null;
 } & ResourceType;
@@ -53,7 +52,6 @@ type ResourcesConfig = Partial<ResourcesInitConfig>;
 declare class ResourceAdapter {
     #private;
     constructor(config: ResourcesInitConfig);
-    get interceptors(): InterceptorManager;
     private localConfig;
     config(config: ResourcesConfig): ResourceAdapter;
     get client(): Readonly<ApiClient>;
@@ -73,9 +71,6 @@ declare abstract class ApiResourceBase<R extends Resource> {
     protected relationshipOneToOne<RR extends ResourceRel>(id: string | ResourceId | null): RR;
     protected relationshipOneToMany<RR extends ResourceRel>(...ids: string[]): RR[];
     abstract type(): ResourceTypeLock;
-    parse(resource: string, options?: {
-        ignoreSlug?: boolean;
-    }): R | R[];
     update(resource: ResourceUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
 }
 declare abstract class ApiResource<R extends Resource> extends ApiResourceBase<R> {

package/lib/esm/resource.js

@@ -2,7 +2,6 @@ import ApiClient from './client';
 import { denormalize, normalize } from './jsonapi';
 import { generateQueryStringParams, isParamsList } from './query';
 import config from './config';
-import { ErrorType, SdkError } from './error';
 import Debug from './debug';
 const debug = Debug('resource');
 class ListResponse extends Array {
@@ -28,7 +27,6 @@ class ResourceAdapter {
         this.#client = ApiClient.create(config);
         this.localConfig(config);
     }
-    get interceptors() { return this.#client.interceptors; }
     localConfig(config) {
         // if (typeof config.xyz !== 'undefined') this.#config.xyz = config.xyz
     }
@@ -48,7 +46,7 @@ class ResourceAdapter {
         const queryParams = generateQueryStringParams(params, resource);
         if (options?.params)
             Object.assign(queryParams, options?.params);
-        const res = await this.#client.request('get', `${resource.type}`, undefined, { ...options, params: queryParams });
+        const res = await this.#client.request('GET', `${resource.type}`, undefined, { ...options, params: queryParams });
         const r = denormalize(res);
         return r;
     }
@@ -57,7 +55,7 @@ class ResourceAdapter {
         const queryParams = generateQueryStringParams(params, resource);
         if (options?.params)
             Object.assign(queryParams, options?.params);
-        const res = await this.#client.request('get', `${resource.type}/${resource.id}`, undefined, { ...options, params: queryParams });
+        const res = await this.#client.request('GET', `${resource.type}/${resource.id}`, undefined, { ...options, params: queryParams });
         const r = denormalize(res);
         return r;
     }
@@ -66,7 +64,7 @@ class ResourceAdapter {
         const queryParams = generateQueryStringParams(params, resource);
         if (options?.params)
             Object.assign(queryParams, options?.params);
-        const res = await this.#client.request('get', `${resource.type}`, undefined, { ...options, params: queryParams });
+        const res = await this.#client.request('GET', `${resource.type}`, undefined, { ...options, params: queryParams });
         const r = denormalize(res);
         const meta = {
             pageCount: Number(res.meta?.page_count),
@@ -82,7 +80,7 @@ class ResourceAdapter {
         if (options?.params)
             Object.assign(queryParams, options?.params);
         const data = normalize(resource);
-        const res = await this.#client.request('post', resource.type, data, { ...options, params: queryParams });
+        const res = await this.#client.request('POST', resource.type, data, { ...options, params: queryParams });
         const r = denormalize(res);
         return r;
     }
@@ -92,20 +90,20 @@ class ResourceAdapter {
         if (options?.params)
             Object.assign(queryParams, options?.params);
         const data = normalize(resource);
-        const res = await this.#client.request('patch', `${resource.type}/${resource.id}`, data, { ...options, params: queryParams });
+        const res = await this.#client.request('PATCH', `${resource.type}/${resource.id}`, data, { ...options, params: queryParams });
         const r = denormalize(res);
         return r;
     }
     async delete(resource, options) {
         debug('delete: %o, %O', resource, options || {});
-        await this.#client.request('delete', `${resource.type}/${resource.id}`, undefined, options);
+        await this.#client.request('DELETE', `${resource.type}/${resource.id}`, undefined, options);
     }
     async fetch(resource, path, params, options) {
         debug('fetch: %o, %O, %O', path, params || {}, options || {});
         const queryParams = generateQueryStringParams(params, resource);
         if (options?.params)
             Object.assign(queryParams, options?.params);
-        const res = await this.#client.request('get', path, undefined, { ...options, params: queryParams });
+        const res = await this.#client.request('GET', path, undefined, { ...options, params: queryParams });
         const r = denormalize(res);
         if (Array.isArray(r)) {
             const p = params;
@@ -127,6 +125,7 @@ class ApiResourceBase {
     constructor(adapter) {
         debug('new resource instance: %s', this.type());
         this.resources = adapter;
+        console.log('CONSTRUCTOR ' + this.type());
     }
     relationshipOneToOne(id) {
         return (((id === null) || (typeof id === 'string')) ? { id, type: this.type() } : { id: id.id, type: this.type() });
@@ -134,29 +133,36 @@ class ApiResourceBase {
     relationshipOneToMany(...ids) {
         return (((ids === null) || (ids.length === 0) || (ids[0] === null)) ? [{ id: null, type: this.type() }] : ids.map(id => { return { id, type: this.type() }; }));
     }
-    parse(resource, options) {
-        try {
-            const res = JSON.parse(resource);
-            // Resource type always checked
-            const rtype = res.data?.type;
-            if (rtype !== this.type())
-                throw new SdkError({ message: `Invalid resource type [${rtype}]`, type: ErrorType.PARSE });
-            // Parse options
-            const { ignoreSlug } = options || {};
-            if (!ignoreSlug) {
-                const links = res.data.links.self;
-                if (!links || !String(links).match(`^${this.resources.client.baseUrl}/${this.type()}/*`))
-                    throw new SdkError({ message: `Resource contains invalid links [${links}]`, type: ErrorType.PARSE });
+    /*
+        parse(resource: string, options?: { ignoreSlug?: boolean }): R | R[] {
+    
+            try {
+    
+                const res = JSON.parse(resource)
+    
+                // Resource type always checked
+                const rtype = res.data?.type
+                if (rtype !== this.type()) throw new SdkError({ message: `Invalid resource type [${rtype}]`, type: ErrorType.PARSE })
+                
+                // Parse options
+                const { ignoreSlug } = options || {}
+    
+                if (!ignoreSlug) {
+                    const links = res.data.links.self
+                    if (!links || !String(links).match(`^${this.resources.client.baseUrl}/${this.type()}/*`))
+                        throw new SdkError({ message: `Resource contains invalid links [${links}]`, type: ErrorType.PARSE })
+                }
+    
+    
+                return denormalize<R>(res as DocWithData)
+    
+            } catch (error: any) {
+                if (SdkError.isSdkError(error)) throw error
+                else throw new SdkError({ message: `Payload parse error [${error.message}]`, type: ErrorType.PARSE })
             }
-            return denormalize(res);
+    
         }
-        catch (error) {
-            if (SdkError.isSdkError(error))
-                throw error;
-            else
-                throw new SdkError({ message: `Payload parse error [${error.message}]`, type: ErrorType.PARSE });
-        }
-    }
+        */
     // reference, reference_origin and metadata attributes are always updatable
     async update(resource, params, options) {
         return this.resources.update({ ...resource, type: this.type() }, params, options);

package/lib/esm/util.js

@@ -15,11 +15,11 @@ const nestedField = (obj: any, field: string): { key: string, val: any } => {
     let fp = field
     if (fp.endsWith('.')) fp = fp.substring(0, fp.length-1)
 
-    const dots = field.split(".")
+  const dots = field.split(".")
 
     const key = dots[dots.length-1]
     let val = obj
-    while (dots.length && (val = val[dots.shift() || '']));
+  while (dots.length && (val = val[dots.shift() || '']))
     
     return { key, val }
 }
@@ -28,9 +28,9 @@ const nestedField = (obj: any, field: string): { key: string, val: any } => {
 const packageInfo = (fields?: string | string[], options?: any): Record<string, any>  => {
     const pjson = require(path.resolve('./', 'package.json'))
     return fields? (Array.isArray(fields)? fields : [ fields ]).reduce((info: any, field) => {
-        const nf = nestedField(pjson, field)
-        info[options?.nestedName? nf.key : field] = nf.val
-        return info
+            const nf = nestedField(pjson, field)
+            info[options?.nestedName? nf.key : field] = nf.val
+            return info
       }, {}) : pjson
 }
 */