@natyapp/meta 1.0.0

package/README.md

@@ -0,0 +1,52 @@
+# SDK MICROSSERVIÇO SECRETARIA NATY / META
+
+## `_UNDER DEVELOPMENT_ `
+
+<!-- `(Will not work until March, please wait the Release)` -->
+
+<!-- ## HOW WILL WORK -->
+
+##### First we will import and Initialize the sdk package
+
+1. importing the package
+
+```
+  import SDKMeta from "NatyMeta"
+```
+
+2. initialize the class
+
+```
+  const SDK = new NatyMeta()
+  // you can use new sdk(`YOUR-APP-TOKEN`) to connect right on the class creation
+```
+
+3. connect your app token (if you dont use your token on class creation)
+
+```
+  const connectSDK = await SDK.connect( {apptoken: { `YOUR-APP-TOKEN` } } )
+
+  if(connectSDK.isError) throw new Error(connectSDK.isError.message)
+
+  console.log(connectSDK.isSuccess)
+        // Do what you need with the data... (connectSDK.isSuccess)
+```
+
+3. than set your application context to use all the individual classes
+
+#### In this example:
+
+    - Retun of any Promise is {isSuccess:AuthReturnType, isError:ErrorHandlingType}
+    - If successed method (like the SDK.connect example too),
+    the sdk will abstract and will handle properly with the token for you,
+    the token will be automatic joined into axios instance header
+    - ErrorHandling type { code: number, message: string | Object }
+    - On the exemple, we are using "throw new Error" on every ErrorHandling to
+    stop and handle it on a simple way, but u can work at your way like
+    returning an alert using some alert lib like toastfy for the user.
+
+<!-- ## Click on [NatyMeta](https://whatsapp.secretarianaty.com) for more information. -->
+
+##### (The link will be avalible soon)
+
+###### All Rights Reserved for Ikiradev

package/dist/Entities/Logs.d.ts

@@ -0,0 +1,16 @@
+import { typeLog } from "../types/logs";
+export declare class LogsEntity {
+    id: string;
+    _id: string;
+    type: typeLog;
+    owner?: string;
+    url?: string;
+    method?: string;
+    remoteIP?: string;
+    errorCode?: string;
+    objectData?: object;
+    isActive: boolean;
+    updatedAt: string;
+    createdAt: string;
+    constructor(props: Omit<LogsEntity, "_id" | "updatedAt" | "createdAt" | "id" | "isActive">, id?: string);
+}

package/dist/Entities/Logs.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogsEntity = void 0;
+const genUuid_1 = require("../utils/genUuid");
+class LogsEntity {
+    constructor(props, id) {
+        this.isActive = true;
+        if (!id)
+            this.id = (0, genUuid_1.genId)("LOG");
+        Object.assign(this, props);
+    }
+}
+exports.LogsEntity = LogsEntity;

package/dist/Entities/QueueMessages.d.ts

@@ -0,0 +1,7 @@
+export declare class QueueEntity {
+    id: string;
+    connectionId: string;
+    method: Object;
+    isActive: boolean;
+    constructor(props: Omit<QueueEntity, "id" | "isActive">, id?: string);
+}

package/dist/Entities/QueueMessages.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueEntity = void 0;
+const genUuid_1 = require("../utils/genUuid");
+class QueueEntity {
+    constructor(props, id) {
+        this.isActive = true;
+        if (!id)
+            this.id = (0, genUuid_1.genId)("queue");
+        Object.assign(this, props);
+    }
+}
+exports.QueueEntity = QueueEntity;

package/dist/Entities/connection.d.ts

@@ -0,0 +1,15 @@
+export declare class ConnectionEntity {
+    id: string;
+    companyId: string;
+    appId: string;
+    appSecret: string;
+    accessToken: string;
+    businessId: string;
+    phoneNumberId: string;
+    phoneNumber: number;
+    isActive: boolean;
+    _id: string;
+    updatedAt: string;
+    createdAt: string;
+    constructor(props: Omit<ConnectionEntity, "_id" | "updatedAt" | "createdAt" | "id" | "isActive">, id?: string);
+}

package/dist/Entities/connection.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionEntity = void 0;
+const genUuid_1 = require("../utils/genUuid");
+class ConnectionEntity {
+    constructor(props, id) {
+        this.isActive = true;
+        if (!id)
+            this.id = (0, genUuid_1.genId)("connection");
+        Object.assign(this, props);
+    }
+}
+exports.ConnectionEntity = ConnectionEntity;

package/dist/Entities/errorLogs.d.ts

@@ -0,0 +1,9 @@
+export declare class ErrorLogEntity {
+    id: string;
+    connectionId: string;
+    errorFrom: string;
+    statusCode: number;
+    error: Error;
+    isActive: boolean;
+    constructor(props: Omit<ErrorLogEntity, "id" | "isActive">, id?: string);
+}

package/dist/Entities/errorLogs.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorLogEntity = void 0;
+const genUuid_1 = require("../utils/genUuid");
+class ErrorLogEntity {
+    constructor(props, id) {
+        this.isActive = true;
+        if (!id)
+            this.id = (0, genUuid_1.genId)("error");
+        Object.assign(this, props);
+    }
+}
+exports.ErrorLogEntity = ErrorLogEntity;

package/dist/Entities/message.d.ts

@@ -0,0 +1,4 @@
+export declare class Message {
+    type: string;
+    constructor(props: Message);
+}

package/dist/Entities/message.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+class Message {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}
+exports.Message = Message;

package/dist/Entities/webhooks.d.ts

@@ -0,0 +1,17 @@
+export declare class WebhooksEntity {
+    id: string;
+    companyId: string;
+    connection: {
+        url: string;
+        active: boolean;
+    };
+    messages: {
+        url: string;
+        active: boolean;
+    };
+    isActive: boolean;
+    _id: string;
+    updatedAt: string;
+    createdAt: string;
+    constructor(props: Omit<WebhooksEntity, "_id" | "updatedAt" | "createdAt" | "id" | "isActive">, id?: string);
+}

package/dist/Entities/webhooks.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhooksEntity = void 0;
+const genUuid_1 = require("../utils/genUuid");
+class WebhooksEntity {
+    constructor(props, id) {
+        this.isActive = true;
+        if (!id)
+            this.id = (0, genUuid_1.genId)("queue");
+        Object.assign(this, props);
+    }
+}
+exports.WebhooksEntity = WebhooksEntity;

package/dist/Errors/Either.d.ts

@@ -0,0 +1,15 @@
+export type isError<T> = {
+    isError: T;
+    isSuccess?: never;
+};
+export type isSuccess<U> = {
+    isError?: never;
+    isSuccess: U;
+};
+export type Either<T, U> = NonNullable<isError<T> | isSuccess<U>>;
+export type UnwrapEither = <T, U>(e: Either<T, U>) => NonNullable<T | U>;
+export declare const unwrapEither: UnwrapEither;
+export declare const isError: <T, U>(e: Either<T, U>) => e is isError<T>;
+export declare const isSuccess: <T, U>(e: Either<T, U>) => e is isSuccess<U>;
+export declare const throwError: <T>(value: T) => isError<T>;
+export declare const throwSuccess: <U>(value: U) => isSuccess<U>;

package/dist/Errors/Either.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwSuccess = exports.throwError = exports.isSuccess = exports.isError = exports.unwrapEither = void 0;
+const unwrapEither = ({ isError, isSuccess, }) => {
+    if (isSuccess !== undefined && isError !== undefined) {
+        throw new Error(`Received both isError and isSuccess values at runtime when opening an Either\nisError: ${JSON.stringify(isError)}\nisSuccess: ${JSON.stringify(isSuccess)}`);
+        /*
+         We're throwing in this function because this can only occur at runtime if something
+         happens that the TypeScript compiler couldn't anticipate. That means the application
+         is in an unexpected state and we should terminate immediately.
+        */
+    }
+    if (isError !== undefined) {
+        return isError; // Typescript is getting confused and returning this type as `T | undefined` unless we add the type assertion
+    }
+    if (isSuccess !== undefined) {
+        return isSuccess;
+    }
+    throw new Error(`Received no isError or isSuccess values at runtime when opening Either`);
+};
+exports.unwrapEither = unwrapEither;
+const isError = (e) => {
+    return e.isError !== undefined;
+};
+exports.isError = isError;
+const isSuccess = (e) => {
+    return e.isSuccess !== undefined;
+};
+exports.isSuccess = isSuccess;
+const throwError = (value) => ({
+    isError: value,
+});
+exports.throwError = throwError;
+const throwSuccess = (value) => ({
+    isSuccess: value,
+});
+exports.throwSuccess = throwSuccess;

package/dist/Errors/ErrorHandling.d.ts

@@ -0,0 +1,10 @@
+export declare const ErrorHandling: (message?: string | Object | any[], code?: number) => ErrorReturnType;
+export type Response<E, S> = {
+    isSuccess: S;
+    isError: E;
+};
+type ErrorReturnType = {
+    code: number;
+    message: string | Object;
+};
+export {};

package/dist/Errors/ErrorHandling.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandling = void 0;
+const ErrorHandling = (message, code) => {
+    if (typeof message === "object")
+        return {
+            code: 500,
+            message,
+        };
+    return {
+        code: code ? code : message ? 400 : 500,
+        message: message || "Erro interno do servidor",
+    };
+};
+exports.ErrorHandling = ErrorHandling;

package/dist/Errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Either";
+export * from "./ErrorHandling";

package/dist/Errors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Either"), exports);
+__exportStar(require("./ErrorHandling"), exports);

package/dist/configs/axiosInterceptors.d.ts

@@ -0,0 +1,7 @@
+export declare const configInterceptors: {
+    Accept: string;
+    "Content-Type": string;
+    "Access-Control-Allow-Headers": string;
+    "Access-Control-Allow-Origin": string;
+    "Access-Control-Allow-Methods": string;
+};

package/dist/configs/axiosInterceptors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configInterceptors = void 0;
+exports.configInterceptors = {
+    ["Accept"]: "application/json",
+    ["Content-Type"]: "application/json; charset=utf-8",
+    ["Access-Control-Allow-Headers"]: "Content-Type",
+    ["Access-Control-Allow-Origin"]: "*",
+    ["Access-Control-Allow-Methods"]: "OPTIONS,POST,GET,PUT,PATCH,DELETE",
+};

package/dist/elements/button.d.ts

@@ -0,0 +1,18 @@
+export declare class Button {
+    type: string;
+    body: {
+        text: string;
+    };
+    action: {
+        buttons: btnType[];
+    };
+    constructor(props: Button);
+}
+type btnType = {
+    type: "reply";
+    reply: {
+        id: string;
+        title: string;
+    };
+};
+export {};

package/dist/elements/button.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Button = void 0;
+class Button {
+    // interactive: Buttons,
+    constructor(props) {
+        this.type = "interactive";
+        this.body = { text: "" };
+        Object.assign(this, props);
+    }
+}
+exports.Button = Button;

package/dist/elements/image.d.ts

@@ -0,0 +1,9 @@
+export declare class Button {
+    messaging_product: string;
+    to: number;
+    type: string;
+    text: {
+        body: string;
+    };
+    constructor(props: Button);
+}

package/dist/elements/image.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Button = void 0;
+class Button {
+    constructor(props) {
+        this.messaging_product = "whatsapp";
+        this.type = "text";
+        this.text = { body: "" };
+        Object.assign(this, props);
+    }
+}
+exports.Button = Button;

package/dist/elements/list.d.ts

@@ -0,0 +1,78 @@
+export declare class List implements list {
+    type: "list";
+    header: {
+        type: "text";
+        text: string;
+    };
+    body: {
+        text: string;
+    };
+    footer: {
+        text: string;
+    };
+    action: actionType;
+    constructor(props: {
+        title: string;
+        subtitle: string;
+        footer?: string;
+        buttonTitle: string;
+    });
+    insertSection(title: string | undefined, btns: rowType[]): void;
+}
+interface list {
+    type: "list";
+    header?: {
+        type: "text";
+        text: string;
+    };
+    body?: {
+        text: string;
+    };
+    footer?: {
+        text: string;
+    };
+    action: actionType;
+}
+type actionType = {
+    button: string;
+    sections: sectionType[];
+};
+type sectionType = {
+    title: string;
+    rows: rowType[];
+};
+type rowType = {
+    id: string;
+    title: string;
+    description: string;
+};
+export declare const ListTeste: ({ subtitle, footer, buttonTitle, name, }: {
+    subtitle?: string | undefined;
+    footer?: string | undefined;
+    buttonTitle: string;
+    name: string;
+}) => {
+    type: string;
+    header: {
+        type: string;
+        text: string;
+    };
+    body: {
+        text: string | undefined;
+    };
+    footer: {
+        text: string | undefined;
+    };
+    action: {
+        button: string;
+        sections: {
+            title: string;
+            rows: {
+                id: string;
+                title: string;
+                description: string;
+            }[];
+        }[];
+    };
+};
+export {};

package/dist/elements/list.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListTeste = exports.List = void 0;
+class List {
+    constructor(props) {
+        this.type = "list";
+        this.header = { type: "text", text: "" };
+        this.body = { text: "" };
+        this.footer = { text: "" };
+        this.action = { button: "", sections: [] };
+        this.header.text = props.title;
+        this.body.text = props.subtitle;
+        this.footer.text = props.footer || "";
+        this.action.button = props.buttonTitle;
+    }
+    insertSection(title = "teste", btns) {
+        let newSection = { title, rows: btns };
+        this.action.sections.push(newSection);
+    }
+}
+exports.List = List;
+const ListTeste = ({ subtitle, footer, buttonTitle, name, }) => ({
+    type: "list",
+    header: {
+        type: "text",
+        text: `Olá, sou ${name}`,
+    },
+    body: {
+        text: subtitle,
+    },
+    footer: {
+        text: footer,
+    },
+    action: {
+        button: buttonTitle,
+        sections: [
+            {
+                title: "Ações",
+                rows: [
+                    {
+                        id: "ticket",
+                        title: "Abrir Ticket",
+                        description: "Clique aqui para solicitar um ticket suporte.",
+                    },
+                    {
+                        id: "suporte",
+                        title: "Atendente",
+                        description: "Clique aqui para solicitar um atendimento direto",
+                    },
+                ],
+            },
+        ],
+    },
+});
+exports.ListTeste = ListTeste;

package/dist/elements/text.d.ts

@@ -0,0 +1,7 @@
+export declare class Text {
+    type: string;
+    text: {
+        body: string;
+    };
+    constructor(text: string);
+}

package/dist/elements/text.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = void 0;
+class Text {
+    constructor(text) {
+        this.type = "text";
+        this.text = { body: "" };
+        this.text.body = text;
+    }
+}
+exports.Text = Text;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { NatyMeta, Log, Webhook, Connection, Message } from "./useCases";
+export { NatyMeta, Connection, Message, Webhook, Log };
+export default NatyMeta;

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.Webhook = exports.Message = exports.Connection = exports.NatyMeta = void 0;
+const useCases_1 = require("./useCases");
+Object.defineProperty(exports, "NatyMeta", { enumerable: true, get: function () { return useCases_1.NatyMeta; } });
+Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return useCases_1.Log; } });
+Object.defineProperty(exports, "Webhook", { enumerable: true, get: function () { return useCases_1.Webhook; } });
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return useCases_1.Connection; } });
+Object.defineProperty(exports, "Message", { enumerable: true, get: function () { return useCases_1.Message; } });
+exports.default = useCases_1.NatyMeta;

package/dist/interfaces/IConnection.d.ts

@@ -0,0 +1,13 @@
+import { ConnectionEntity } from "../Entities/connection";
+import { Either } from "../Errors";
+import { getAllProps, getAllReturn } from "../types/requestTypes";
+export interface IConnection {
+    insert(connection: Partial<ConnectionEntity>): Promise<Either<connectionErrors, ConnectionEntity>>;
+    getSingle(id: string): Promise<Either<connectionErrors, ConnectionEntity>>;
+    SearchOne(key: string, value: string): Promise<Either<connectionErrors, ConnectionEntity>>;
+    getAll(props: getAllProps): Promise<Either<connectionErrors, getAllReturn<ConnectionEntity>>>;
+    update(id: string, connection: Partial<ConnectionEntity>): Promise<Either<connectionErrors, ConnectionEntity>>;
+    updateMany(connection: Partial<ConnectionEntity>[]): Promise<Either<connectionErrors, ConnectionEntity[]>>;
+    deleteOne(id: string): Promise<Either<connectionErrors, ConnectionEntity>>;
+}
+export type connectionErrors = "";

package/dist/interfaces/IConnection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/ILog.d.ts

@@ -0,0 +1,10 @@
+import { LogsEntity } from "../Entities/Logs";
+import { Either } from "../Errors";
+import { getAllProps, getAllReturn } from "../types/requestTypes";
+export interface ILog {
+    getSingle(key: string): Promise<Either<logErrors, LogsEntity>>;
+    getAll(props: getAllProps): Promise<Either<logErrors, getAllReturn<LogsEntity>>>;
+    searchOne(key: keyof LogsEntity, value: string): Promise<Either<logErrors, LogsEntity>>;
+}
+type logErrors = "";
+export {};

package/dist/interfaces/ILog.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/IMessage.d.ts

@@ -0,0 +1,8 @@
+import { Button } from "../elements/button";
+import { List } from "../elements/list";
+import { Text } from "../elements/text";
+export interface IMessage {
+    text: Text;
+    button: typeof Button;
+    list: List;
+}

package/dist/interfaces/IMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/ISdk.d.ts

@@ -0,0 +1,13 @@
+import { Response } from "../Errors/ErrorHandling";
+import { Connection, Log, Message, Webhook } from "../useCases";
+export interface ISdk {
+    connect({ appToken, }: ConnectProps): Promise<Response<ConnectErrors, boolean>>;
+    Connection: typeof Connection;
+    Message: typeof Message;
+    Webhook: typeof Webhook;
+    Log: typeof Log;
+}
+export type ConnectProps = {
+    appToken: string;
+};
+export type ConnectErrors = "AppToken inválido";

package/dist/interfaces/ISdk.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/IWebhook.d.ts

@@ -0,0 +1,14 @@
+import { WebhooksEntity } from "../Entities/webhooks";
+import { Either } from "../Errors";
+import { getAllProps, getAllReturn } from "../types/requestTypes";
+export interface IWebhook {
+    insert(webhook: Partial<WebhooksEntity>): Promise<Either<webhookErrors, WebhooksEntity>>;
+    getSingle(id: string): Promise<Either<webhookErrors, WebhooksEntity>>;
+    searchOne(key: string, value: string): Promise<Either<webhookErrors, WebhooksEntity>>;
+    getAll(props: getAllProps): Promise<Either<webhookErrors, getAllReturn<WebhooksEntity>>>;
+    update(id: string, connection: Partial<WebhooksEntity>): Promise<Either<webhookErrors, WebhooksEntity>>;
+    updateMany(connection: Partial<WebhooksEntity>[]): Promise<Either<webhookErrors, WebhooksEntity[]>>;
+    deleteOne(id: string): Promise<Either<webhookErrors, WebhooksEntity>>;
+}
+type webhookErrors = "";
+export {};

package/dist/interfaces/IWebhook.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });