@short.io/client-node 1.1.0 → 2.0.1

package/README.md

@@ -1,6 +1,7 @@
 # Short.io Node.js SDK
 
 The Short.io Node.js official SDK client is a library that allows you to integrate [short.io](https://short.io) URL shortening and link management API with your Node.js application in an easy and elegant way.
+This SDK contains methods for working with links and domains.
 
 ## API reference
 
@@ -8,7 +9,7 @@ See the [API docs](https://developers.short.io/reference) for more information.
 
 ## Installing
 
-To install this package, type:
+To install the SDK, run:
 
 ```sh
 npm i @short.io/client-node
@@ -17,59 +18,48 @@ npm i @short.io/client-node
 ## Getting Started
 
 First you need to get your API key from the Short.io dashboard in the [Integrations & API](https://app.short.io/settings/integrations/api-key) section.
-This SDK contains methods for working with links, domains and statistics. Import the Shortio class:
+Then you need to set the configuration for the client:
 
 ```js
-import { Shortio } from "shortio";
-```
-
-## Usage
-
-Then create an instance of the Shortio class, and pass your API key as the first parameter:
+import { client } from "@short.io/client-node";
 
-```js
-const shortio = new Shortio("YOUR_API_KEY");
+client.setConfig({
+    baseUrl: "https://api.short.io",
+    headers: {
+        Authorization: "YOUR_API_KEY",
+    },
+});
 ```
 
-To get the domain list, you can use the following code:
-
-```js
-const domains = await shortio.domain.list();
-```
+## Usage
 
-Get the link list of the first domain above:
+Import the needed methods from the SDK and use them in your code:
 
 ```js
-const links = await shortio.link.list(domains[0].id);
+import {
+    client,
+    getApiDomains,
+    getLinksExpand,
+    // and other needed methods
+} from "@short.io/client-node";
 ```
 
-Get the link statistics of the first link above:
+Pass created client to the methods:
 
 ```js
-const stats = await shortio.statistics.getByLink(links[0].idString);
+const domainsResp = await getApiDomains({ client });
 ```
 
-Create links:
+`domainsResp.data` will contain the list of domains.
 
 ```js
-const link = await shortio.link.create({
-  domain: "link.example.com",
-  path: "example",
-  originalURL: "https://example.com",
+const linkResp = await getLinksExpand({
+    client,
+    query: {
+        domain: "your_domain.com",
+        path: "lnk_abc123_abcde12345,
+    },
 });
-console.log(link.shortURL); // https://link.example.com/example
-
-const publicLink = await shortio.link.createPublic({
-  domain: "link.example.com",
-  originalURL: "https://example.com",
-  publicAPIKey: "PUBLIC_API_KEY",
-});
-console.log(publicLink.shortURL); // https://link.example.com/a83t48
+```
 
-const secureLink = await shortio.link.createSecure({
-  domain: "link.example.com",
-  publicAPIKey: "PUBLIC_API_KEY",
-  originalURL: "https://example.com",
-});
-console.log(secureLink.shortURL); // https://link.example.com/a83t48#ta95me8
-```
+`linkResp.data` will contain the expanded link.

package/dist/index.d.ts

@@ -1,54 +1,2 @@
-import { ErrorResBody, StatusResBody, SuccessResBody } from "./types/common.js";
-import { Domain, DomainCreateOptions } from "./types/domain.js";
-import { DeleteLinkRes, GetLinkQRCodeOptions, Link, LinkBulkCreateOptions, LinkCountry, LinkCountryCreateOptions, LinkCreateOptions, LinkListOptions, LinkOpenGraphData, LinkRegion, LinkRegionCreateOptions, LinkRegionDeleteOptions, LinkUpdateOptions, LinkWithUser, LinksAndCount, UpdateLinkErrorRes } from "./types/link.js";
-import { Column, DomainStatistics, FilterOptions, GetLastClicksOptions, GetStatisticsOptions, IncludeExcludeOptions, LastClicksRes, LinkClicks, LinkIds, LinkStatistics, PathClicks, PathDate, StartEndDate, TopByColumnOptions, TopByIntervalOptions, TopByIntervalRes, TopColumnRes } from "./types/statistics.js";
-export declare class Shortio {
-    private readonly apiKey;
-    private readonly baseApiUrl;
-    private readonly baseStatisticsUrl;
-    constructor(apiKey: string);
-    readonly link: {
-        list: (domainId: Domain["id"], options?: LinkListOptions) => Promise<LinksAndCount | ErrorResBody>;
-        getByPath: (hostname: Domain["hostname"], path: Link["path"]) => Promise<Link | ErrorResBody>;
-        getByOriginalURL: (hostname: Domain["hostname"], originalURL: Link["originalURL"]) => Promise<Link | ErrorResBody>;
-        create: (hostname: Domain["hostname"], originalURL: Link["originalURL"], options?: LinkCreateOptions) => Promise<Link | ErrorResBody>;
-        createPublic: (hostname: Domain["hostname"], originalURL: Link["originalURL"], publicAPIKey: string, options?: LinkCreateOptions) => Promise<Link | (SuccessResBody & ErrorResBody)>;
-        createSecure: (hostname: Domain["hostname"], originalURL: Link["originalURL"], publicAPIKey: string, options?: LinkCreateOptions) => Promise<Link | ErrorResBody>;
-        bulkCreate: (hostname: Domain["hostname"], links: LinkBulkCreateOptions[], allowDuplicates?: boolean) => Promise<(Link & SuccessResBody)[] | (SuccessResBody & ErrorResBody & StatusResBody)>;
-        archive: (linkIdString: Link["idString"]) => Promise<SuccessResBody | ErrorResBody>;
-        update: (linkIdString: Link["idString"], options: LinkUpdateOptions) => Promise<LinkWithUser | UpdateLinkErrorRes>;
-        delete: (linkIdString: Link["idString"]) => Promise<DeleteLinkRes | ErrorResBody>;
-        generateQRCode: (linkIdString: Link["idString"], options?: GetLinkQRCodeOptions) => Promise<ErrorResBody | Buffer>;
-        getOpenGraph: (domainId: Domain["id"], linkIdString: Link["idString"]) => Promise<LinkOpenGraphData | ErrorResBody>;
-        updateOpenGraph: (domainId: Domain["id"], linkIdString: Link["idString"], newOpenGraphData: LinkOpenGraphData) => Promise<LinkOpenGraphData | ErrorResBody>;
-    };
-    readonly domain: {
-        list: () => Promise<Domain[] | ErrorResBody>;
-        create: (hostname: Domain["hostname"], options?: DomainCreateOptions) => Promise<Domain | ErrorResBody>;
-    };
-    readonly linkCountry: {
-        list: (linkIdString: Link["idString"]) => Promise<LinkCountry[] | ErrorResBody>;
-        create: (linkIdString: Link["idString"], options: LinkCountryCreateOptions) => Promise<LinkCountry | ErrorResBody>;
-        delete: (linkIdString: Link["idString"], country: LinkCountry["country"]) => Promise<SuccessResBody | ErrorResBody>;
-    };
-    readonly linkRegion: {
-        list: (linkIdString: Link["idString"]) => Promise<LinkRegion[] | ErrorResBody>;
-        create: (linkIdString: Link["idString"], options: LinkRegionCreateOptions) => Promise<LinkRegion | ErrorResBody>;
-        delete: (linkIdString: Link["idString"], options: LinkRegionDeleteOptions) => Promise<SuccessResBody | ErrorResBody>;
-    };
-    readonly statistics: {
-        getByLink: (linkIdString: Link["idString"], options?: GetStatisticsOptions) => Promise<LinkStatistics | ErrorResBody>;
-        getByLinkPost: (linkIdString: Link["idString"], options?: GetStatisticsOptions & {
-            include?: FilterOptions;
-            exclude?: FilterOptions;
-        }) => Promise<LinkStatistics | ErrorResBody>;
-        getByDomain: (domainId: Domain["id"], options?: GetStatisticsOptions) => Promise<DomainStatistics | ErrorResBody>;
-        getByDomainPost: (domainId: Domain["id"], options?: GetStatisticsOptions & IncludeExcludeOptions) => Promise<DomainStatistics | ErrorResBody>;
-        getLinkClicks: (domainId: Domain["id"], options: StartEndDate & LinkIds) => Promise<LinkClicks | ErrorResBody>;
-        getLinkClicksByPathDates: (domainId: Domain["id"], pathsDates: PathDate[], options?: StartEndDate) => Promise<PathClicks | ErrorResBody>;
-        getTopByColumn: (domainId: Domain["id"], column: Column, options?: TopByColumnOptions) => Promise<TopColumnRes[]>;
-        getTopByInterval: (domainId: Domain["id"], column: Column, options?: TopByIntervalOptions) => Promise<TopByIntervalRes[] | ErrorResBody>;
-        getLastClicks: (domainId: Domain["id"], options?: GetLastClicksOptions) => Promise<LastClicksRes | ErrorResBody>;
-        clear: (domainId: Domain["id"]) => Promise<SuccessResBody | ErrorResBody>;
-    };
-}
+export * from "./types.gen.js";
+export * from "./sdk.gen.js";

package/dist/index.js

@@ -1,438 +1,3 @@
-export class Shortio {
-    apiKey;
-    baseApiUrl = "https://api.short.io";
-    baseStatisticsUrl = "https://api-v2.short.cm/statistics";
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    link = {
-        list: async (domainId, options) => {
-            let queryString = `domain_id=${domainId}`;
-            if (options) {
-                for (const param in options) {
-                    queryString += `&${param}=${options[param]}`;
-                }
-            }
-            const linksRes = await fetch(`${this.baseApiUrl}/api/links?${queryString}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linksData = await linksRes.json();
-            return linksData;
-        },
-        getByPath: async (hostname, path) => {
-            const queryString = `domain=${hostname}&path=${path}`;
-            const linkInfoRes = await fetch(`${this.baseApiUrl}/links/expand?${queryString}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkInfo = await linkInfoRes.json();
-            return linkInfo;
-        },
-        getByOriginalURL: async (hostname, originalURL) => {
-            const queryString = `domain=${hostname}&originalURL=${originalURL}`;
-            const linkInfoRes = await fetch(`${this.baseApiUrl}/links/by-original-url?${queryString}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkInfo = await linkInfoRes.json();
-            return linkInfo;
-        },
-        create: async (hostname, originalURL, options) => {
-            const linkRes = await fetch(`${this.baseApiUrl}/links`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({
-                    domain: hostname,
-                    originalURL,
-                    ...options,
-                }),
-            });
-            const link = await linkRes.json();
-            return link;
-        },
-        createPublic: async (hostname, originalURL, publicAPIKey, options) => {
-            const linkRes = await fetch(`${this.baseApiUrl}/links/public`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: publicAPIKey,
-                },
-                body: JSON.stringify({
-                    domain: hostname,
-                    originalURL,
-                    ...options,
-                }),
-            });
-            const link = (await linkRes.json());
-            return link;
-        },
-        createSecure: async (hostname, originalURL, publicAPIKey, options) => {
-            const cryptoKey = await crypto.subtle.generateKey({
-                name: "AES-GCM",
-                length: 128,
-            }, true, ["encrypt", "decrypt"]);
-            const iv = crypto.getRandomValues(new Uint8Array(12));
-            const urlData = new TextEncoder().encode(originalURL);
-            const encryptedUrl = await crypto.subtle.encrypt({
-                name: "AES-GCM",
-                iv,
-            }, cryptoKey, urlData);
-            const encryptedUrlBase64 = Buffer.from(encryptedUrl).toString("base64");
-            const encryptedIvBase64 = Buffer.from(iv).toString("base64");
-            const encryptedData = `shortsecure://${encryptedUrlBase64}?${encryptedIvBase64}`;
-            const link = (await this.link.createPublic(hostname, encryptedData, publicAPIKey, options));
-            if ("error" in link) {
-                return {
-                    error: link.error,
-                };
-            }
-            const exportedKey = await crypto.subtle.exportKey("raw", cryptoKey);
-            const keyBase64 = Buffer.from(new Uint8Array(exportedKey)).toString("base64");
-            link.shortURL += `#${keyBase64}`;
-            link.secureShortURL += `#${keyBase64}`;
-            return link;
-        },
-        bulkCreate: async (hostname, links, allowDuplicates = false) => {
-            const linkRes = await fetch(`${this.baseApiUrl}/links/bulk`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({
-                    domain: hostname,
-                    links,
-                    allowDuplicates,
-                }),
-            });
-            const link = await linkRes.json();
-            return link;
-        },
-        archive: async (linkIdString) => {
-            const res = await fetch(`${this.baseApiUrl}/links/archive`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({
-                    link_id: linkIdString,
-                }),
-            });
-            const linkArchiveRes = await res.json();
-            return linkArchiveRes;
-        },
-        update: async (linkIdString, options) => {
-            const res = await fetch(`${this.baseApiUrl}/links/${linkIdString}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const linkUpdateRes = await res.json();
-            return linkUpdateRes;
-        },
-        delete: async (linkIdString) => {
-            const res = await fetch(`${this.baseApiUrl}/links/${linkIdString}`, {
-                method: "DELETE",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkDeleteRes = await res.json();
-            return linkDeleteRes;
-        },
-        generateQRCode: async (linkIdString, options) => {
-            const res = await fetch(`${this.baseApiUrl}/links/qr/${linkIdString}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const buffer = Buffer.from(await res.arrayBuffer());
-            return buffer;
-        },
-        getOpenGraph: async (domainId, linkIdString) => {
-            const res = await fetch(`${this.baseApiUrl}/links/opengraph/${domainId}/${linkIdString}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const openGraphData = await res.json();
-            return openGraphData;
-        },
-        updateOpenGraph: async (domainId, linkIdString, newOpenGraphData) => {
-            const res = await fetch(`${this.baseApiUrl}/links/opengraph/${domainId}/${linkIdString}`, {
-                method: "PUT",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(newOpenGraphData),
-            });
-            const openGraphData = await res.json();
-            return openGraphData;
-        },
-    };
-    domain = {
-        list: async () => {
-            const domainsRes = await fetch(`${this.baseApiUrl}/api/domains`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const domains = await domainsRes.json();
-            return domains;
-        },
-        create: async (hostname, options) => {
-            const domainsRes = await fetch(`${this.baseApiUrl}/domains`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({
-                    hostname,
-                    ...options,
-                }),
-            });
-            const domain = await domainsRes.json();
-            return domain;
-        },
-    };
-    linkCountry = {
-        list: async (linkIdString) => {
-            const res = await fetch(`${this.baseApiUrl}/link_country/${linkIdString}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkCountries = await res.json();
-            return linkCountries;
-        },
-        create: async (linkIdString, options) => {
-            const res = await fetch(`${this.baseApiUrl}/link_country/${linkIdString}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const linkCountry = await res.json();
-            return linkCountry;
-        },
-        delete: async (linkIdString, country) => {
-            const res = await fetch(`${this.baseApiUrl}/link_country/${linkIdString}/${country}`, {
-                method: "DELETE",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkCountryDeleteRes = await res.json();
-            return linkCountryDeleteRes;
-        },
-    };
-    linkRegion = {
-        list: async (linkIdString) => {
-            const res = await fetch(`${this.baseApiUrl}/link_region/${linkIdString}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkRegions = await res.json();
-            return linkRegions;
-        },
-        create: async (linkIdString, options) => {
-            const res = await fetch(`${this.baseApiUrl}/link_region/${linkIdString}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const linkRegion = await res.json();
-            return linkRegion;
-        },
-        delete: async (linkIdString, options) => {
-            const res = await fetch(`${this.baseApiUrl}/link_region/${linkIdString}/${options.country}/${options.region}`, {
-                method: "DELETE",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const linkRegionDeleteRes = await res.json();
-            return linkRegionDeleteRes;
-        },
-    };
-    statistics = {
-        getByLink: async (linkIdString, options) => {
-            let queryString = "";
-            if (options) {
-                for (const param in options) {
-                    queryString += `&${param}=${options[param]}`;
-                }
-            }
-            const res = await fetch(`${this.baseStatisticsUrl}/link/${linkIdString}${queryString ? "?" + queryString : ""}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getByLinkPost: async (linkIdString, options) => {
-            const res = await fetch(`${this.baseStatisticsUrl}/link/${linkIdString}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getByDomain: async (domainId, options) => {
-            let queryString = "";
-            if (options) {
-                for (const param in options) {
-                    queryString += `&${param}=${options[param]}`;
-                }
-            }
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}${queryString ? "?" + queryString : ""}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getByDomainPost: async (domainId, options) => {
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getLinkClicks: async (domainId, options) => {
-            let queryString = "";
-            for (const param in options) {
-                queryString += `&${param}=${options[param]}`;
-            }
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}/link_clicks${queryString ? "?" + queryString : ""}`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getLinkClicksByPathDates: async (domainId, pathsDates, options) => {
-            let queryString = "";
-            if (options) {
-                for (const param in options) {
-                    queryString += `&${param}=${options[param]}`;
-                }
-            }
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}/link_clicks${queryString ? "?" + queryString : ""}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({ pathsDates }),
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getTopByColumn: async (domainId, column, options) => {
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}/top`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({ column, ...options }),
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getTopByInterval: async (domainId, column, options) => {
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}/top_by_interval`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify({ column, ...options }),
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        getLastClicks: async (domainId, options) => {
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}/last_clicks`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-                body: JSON.stringify(options),
-            });
-            const statistics = await res.json();
-            return statistics;
-        },
-        clear: async (domainId) => {
-            const res = await fetch(`${this.baseStatisticsUrl}/domain/${domainId}/statistics`, {
-                method: "DELETE",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: this.apiKey,
-                },
-            });
-            const deleteRes = await res.json();
-            return deleteRes;
-        },
-    };
-}
+export * from "./types.gen.js";
+export * from "./sdk.gen.js";
 //# sourceMappingURL=index.js.map