@dataggo/node-akeneo-api 1.0.0

package/dist/mjs/error-handler.js

@@ -0,0 +1,33 @@
+import { path } from 'ramda';
+const cleanHeaders = (headers) => headers && headers.Authorization
+    ? {
+        ...headers,
+        Authorization: `Bearer ${`...${headers.Authorization.substr(-5)}`}`,
+    }
+    : headers;
+export default function errorHandler({ config, response }) {
+    const data = response?.data;
+    const errorData = {
+        status: response?.status,
+        statusText: response?.statusText,
+        message: data && 'message' in data ? data.message : '',
+        details: data && 'details' in data ? data.details : {},
+        request: config
+            ? {
+                url: config.url,
+                headers: cleanHeaders(config.headers),
+                method: config.method,
+                payloadData: config.data,
+            }
+            : {},
+    };
+    const error = new Error();
+    error.name = `${response?.status} ${response?.statusText}`;
+    try {
+        error.message = JSON.stringify(errorData, null, '  ');
+    }
+    catch {
+        error.message = path(['message'], errorData) || '';
+    }
+    throw error;
+}

package/dist/mjs/http-client.d.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance } from 'axios';
+import { AppParams, ClientParams } from './types';
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+export declare const createConnectionHttpClient: (options: ClientParams) => AxiosInstance;
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+export declare const createAppHttpClient: (options: AppParams) => AxiosInstance;

package/dist/mjs/http-client.js

@@ -0,0 +1,86 @@
+/* eslint-disable no-underscore-dangle */
+import qs from 'qs';
+import axios from 'axios';
+const TOKEN_PATH = '/api/oauth/v1/token';
+const defaultConfig = {
+    insecure: false,
+    retryOnError: true,
+    headers: {},
+    httpAgent: false,
+    httpsAgent: false,
+    timeout: 30000,
+    proxy: false,
+    basePath: '',
+    adapter: undefined,
+    maxContentLength: 1073741824,
+    paramsSerializer: qs.stringify,
+};
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+export const createConnectionHttpClient = (options) => {
+    let accessToken = '';
+    const { url, clientId, secret, username, password } = options;
+    const baseURL = url.replace(/\/+$/, '');
+    const instance = axios.create({
+        ...defaultConfig,
+        ...(options.axiosOptions || {}),
+        baseURL,
+    });
+    const base64Encoded = Buffer.from(`${clientId}:${secret}`).toString('base64');
+    const refreshAccessToken = async () => {
+        const tokenResult = await axios.post(`${baseURL}${TOKEN_PATH}`, { grant_type: 'password', username, password }, {
+            headers: {
+                Authorization: `Basic ${base64Encoded}`,
+            },
+        });
+        accessToken = tokenResult.data.access_token;
+        return accessToken;
+    };
+    instance.interceptors.request.use(async (config) => ({
+        ...config,
+        headers: {
+            ...config.headers,
+            Authorization: `Bearer ${accessToken || (await refreshAccessToken())}`,
+        },
+    }));
+    instance.interceptors.response.use((response) => response, async (error) => {
+        const originalRequest = error.config;
+        if (error.response &&
+            (error.response.status === 403 || error.response.status === 401) &&
+            !originalRequest._retry) {
+            originalRequest._retry = true;
+            accessToken = '';
+            originalRequest.headers.Authorization = `Bearer ${await refreshAccessToken()}`;
+            return instance(originalRequest);
+        }
+        return Promise.reject(error);
+    });
+    return instance;
+};
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+export const createAppHttpClient = (options) => {
+    const { url, accessToken } = options;
+    const baseURL = url.replace(/\/+$/, '');
+    const instance = axios.create({
+        ...defaultConfig,
+        ...(options.axiosOptions || {}),
+        baseURL,
+    });
+    instance.interceptors.request.use(async (config) => ({
+        ...config,
+        headers: {
+            ...config.headers,
+            Authorization: `Bearer ${accessToken}`,
+        },
+    }));
+    return instance;
+};

package/dist/mjs/index.d.ts

@@ -0,0 +1,349 @@
+/**
+ * Akeneo Management API SDK. Allows you to create instances of a client
+ * with access to the Akeneo API.
+ */
+import { AxiosInstance } from 'axios';
+import { AppParams, ClientParams } from './types';
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   username: AKENEO_USERNAME,
+ *   password: AKENEO_PASSWORD,
+ *   clientId: AKENEO_CLIENT_ID,
+ *   secret: AKENEO_SECRET,
+ * });
+ * ```
+ */
+export declare const createClient: (params: ClientParams) => {
+    raw: {
+        http: AxiosInstance;
+    };
+    category: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Category<Record<string, any>>>;
+        get: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+        getAll: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+    };
+    productModel: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").ProductModel>;
+        get: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+        getAll: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+    };
+    product: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Product>;
+        get: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+        getAll: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+    };
+    assetFamily: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").AssetFamily>;
+        get: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAll: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAssets: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+        getAsset: (params: {
+            assetFamilyCode: string;
+            code: string;
+        }) => Promise<import("./types").Asset>;
+        getAssetsAll: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+    };
+    assetMediaFile: {
+        /**
+         *
+         * @see https://api.akeneo.com/api-reference.html#get_asset_media_files__code
+         */
+        get: (code: string) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntitiesMediaFile: {
+        /**
+         * @see https://api.akeneo.com/api-reference.html#get_reference_entity_media_files__code
+         */
+        get: (code: string) => Promise<any>;
+    };
+    attribute: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").Attribute>;
+        get: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getAll: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getOptions: (params: {
+            attributeCode: string;
+            query?: import("./types").AttributeOptionQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AttributeOption>>;
+        add: ({ code, attribute }: {
+            code: string;
+            attribute: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        addOption: ({ attributeCode, code, option, }: {
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntity: {
+        get: (params: {
+            query?: import("./types").ReferenceEntityQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Entity>>;
+        getRecords: (params: {
+            referenceEntityCode: string;
+            query?: import("./types").ReferenceEntityRecordQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").EntityRecord>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity__code_
+         */ add: ({ code, body }: {
+            code: string;
+            body: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__code_
+         */
+        addAttribute: ({ referenceEntityCode, code, attribute, }: {
+            referenceEntityCode: string;
+            code: string;
+            attribute: any;
+        }) => Promise<void>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__attribute_code__options__code_
+         */
+        addAttributeOption: ({ referenceEntityCode, attributeCode, code, option, }: {
+            referenceEntityCode: string;
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_records
+         */
+        addRecords: ({ referenceEntityCode, records, }: {
+            referenceEntityCode: string;
+            records: any[];
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    family: {
+        get: (params: {
+            query?: import("./types").FamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Family>>;
+        getVariants: (params: {
+            familyCode: string;
+            query?: import("./types").FamilyVariantQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Variant>>;
+    };
+};
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   accessToken: AKENEO_SECRET,
+ * });
+ * ```
+ */
+export declare const createAppClient: (params: AppParams) => {
+    raw: {
+        http: AxiosInstance;
+    };
+    category: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Category<Record<string, any>>>;
+        get: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+        getAll: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+    };
+    productModel: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").ProductModel>;
+        get: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+        getAll: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+    };
+    product: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Product>;
+        get: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+        getAll: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+    };
+    assetFamily: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").AssetFamily>;
+        get: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAll: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAssets: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+        getAsset: (params: {
+            assetFamilyCode: string;
+            code: string;
+        }) => Promise<import("./types").Asset>;
+        getAssetsAll: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+    };
+    assetMediaFile: {
+        /**
+         *
+         * @see https://api.akeneo.com/api-reference.html#get_asset_media_files__code
+         */
+        get: (code: string) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntitiesMediaFile: {
+        /**
+         * @see https://api.akeneo.com/api-reference.html#get_reference_entity_media_files__code
+         */
+        get: (code: string) => Promise<any>;
+    };
+    attribute: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").Attribute>;
+        get: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getAll: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getOptions: (params: {
+            attributeCode: string;
+            query?: import("./types").AttributeOptionQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AttributeOption>>;
+        add: ({ code, attribute }: {
+            code: string;
+            attribute: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        addOption: ({ attributeCode, code, option, }: {
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntity: {
+        get: (params: {
+            query?: import("./types").ReferenceEntityQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Entity>>;
+        getRecords: (params: {
+            referenceEntityCode: string;
+            query?: import("./types").ReferenceEntityRecordQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").EntityRecord>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity__code_
+         */ add: ({ code, body }: {
+            code: string;
+            body: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__code_
+         */
+        addAttribute: ({ referenceEntityCode, code, attribute, }: {
+            referenceEntityCode: string;
+            code: string;
+            attribute: any;
+        }) => Promise<void>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__attribute_code__options__code_
+         */
+        addAttributeOption: ({ referenceEntityCode, attributeCode, code, option, }: {
+            referenceEntityCode: string;
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_records
+         */
+        addRecords: ({ referenceEntityCode, records, }: {
+            referenceEntityCode: string;
+            records: any[];
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    family: {
+        get: (params: {
+            query?: import("./types").FamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Family>>;
+        getVariants: (params: {
+            familyCode: string;
+            query?: import("./types").FamilyVariantQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Variant>>;
+    };
+};
+export declare type AkeneoClientAPI = ReturnType<typeof createClient>;
+export * from './types';

package/dist/mjs/index.js

@@ -0,0 +1,124 @@
+/**
+ * Akeneo Management API SDK. Allows you to create instances of a client
+ * with access to the Akeneo API.
+ */
+import { createConnectionHttpClient, createAppHttpClient } from './http-client';
+import * as endpoints from './endpoints';
+const ATTRIBUTES_PATH = '/api/rest/v1/attributes';
+const ASSET_MEDIA_FILES = '/api/rest/v1/asset-media-files';
+const REFERENCE_ENTITIES_MEDIA_FILES = '/api/rest/v1/reference-entities-media-files';
+const wrap = (http, fn) => (params) => fn(http, params);
+const getHttpClientWithEndpoint = (http) => ({
+    raw: {
+        http,
+    },
+    category: {
+        getOne: wrap(http, endpoints.category.getOne),
+        get: wrap(http, endpoints.category.get),
+        getAll: wrap(http, endpoints.category.getAll),
+    },
+    productModel: {
+        getOne: wrap(http, endpoints.productModel.getOne),
+        get: wrap(http, endpoints.productModel.get),
+        getAll: wrap(http, endpoints.productModel.getAll),
+    },
+    product: {
+        getOne: wrap(http, endpoints.product.getOne),
+        get: wrap(http, endpoints.product.get),
+        getAll: wrap(http, endpoints.product.getAll),
+    },
+    assetFamily: {
+        getOne: wrap(http, endpoints.assetFamily.getOne),
+        get: wrap(http, endpoints.assetFamily.get),
+        getAll: wrap(http, endpoints.assetFamily.getAll),
+        getAssets: wrap(http, endpoints.assetFamily.getAssets),
+        getAsset: wrap(http, endpoints.assetFamily.getAsset),
+        getAssetsAll: wrap(http, endpoints.assetFamily.getAssetsAll),
+    },
+    assetMediaFile: {
+        /**
+         *
+         * @see https://api.akeneo.com/api-reference.html#get_asset_media_files__code
+         */
+        get: async (code) => http.get(`${ASSET_MEDIA_FILES}/${code}`, {
+            responseType: 'arraybuffer',
+            params: {},
+        }),
+    },
+    referenceEntitiesMediaFile: {
+        /**
+         * @see https://api.akeneo.com/api-reference.html#get_reference_entity_media_files__code
+         */
+        get: async (code) => http.get(`${REFERENCE_ENTITIES_MEDIA_FILES}/${code}`, {
+            responseType: 'arraybuffer',
+            params: {},
+        }),
+    },
+    attribute: {
+        getOne: wrap(http, endpoints.attribute.getOne),
+        get: wrap(http, endpoints.attribute.get),
+        getAll: wrap(http, endpoints.attribute.getAll),
+        getOptions: wrap(http, endpoints.attribute.getOptions),
+        add: async ({ code, attribute }) => http.patch(`${ATTRIBUTES_PATH}/${code}`, attribute),
+        addOption: async ({ attributeCode, code, option, }) => http.patch(`${ATTRIBUTES_PATH}/${attributeCode}/options/${code}`, option),
+    },
+    referenceEntity: {
+        get: wrap(http, endpoints.referenceEntity.get),
+        getRecords: wrap(http, endpoints.referenceEntity.getRecords),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity__code_
+         */ add: async ({ code, body }) => http.patch(`/api/rest/v1/reference-entities/${code}`, body),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__code_
+         */
+        addAttribute: async ({ referenceEntityCode, code, attribute, }) => {
+            await http.patch(`/api/rest/v1/reference-entities/${referenceEntityCode}/attributes/${code}`, attribute);
+        },
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__attribute_code__options__code_
+         */
+        addAttributeOption: ({ referenceEntityCode, attributeCode, code, option, }) => http.patch(`/api/rest/v1/reference-entities/${referenceEntityCode}/attributes/${attributeCode}/options/${code}`, option),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_records
+         */
+        addRecords: ({ referenceEntityCode, records, }) => http.patch(`/api/rest/v1/reference-entities/${referenceEntityCode}/records`, records),
+    },
+    family: {
+        get: wrap(http, endpoints.family.get),
+        getVariants: wrap(http, endpoints.family.getVariants),
+    },
+});
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   username: AKENEO_USERNAME,
+ *   password: AKENEO_PASSWORD,
+ *   clientId: AKENEO_CLIENT_ID,
+ *   secret: AKENEO_SECRET,
+ * });
+ * ```
+ */
+export const createClient = (params) => {
+    const http = createConnectionHttpClient(params);
+    return getHttpClientWithEndpoint(http);
+};
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   accessToken: AKENEO_SECRET,
+ * });
+ * ```
+ */
+export const createAppClient = (params) => {
+    const http = createAppHttpClient(params);
+    return getHttpClientWithEndpoint(http);
+};
+export * from './types';

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}