@warpstore/warpstore-package 1.0.0

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@warpstore/warpstore-package",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/src/main.js",
+    "types": "dist/src/main.d.ts",
+    "repository": "https://github.com/Warp-Store/warpstore-package",
+    "scripts": {
+        "prebuild": "rimraf dist",
+        "build": "ttsc",
+        "build:w": "ttsc -w",
+        "dev": "ts-node-dev -r tsconfig-paths/register --respawn --poll --inspect --exit-child ./src/index.ts",
+        "test:unit": "npx tsc --noEmit && npm run test:skipchecks -- --config jest.config.ts",
+        "test:integration": "npx tsc --noEmit && npm run test:skipchecks -- --config jest.config.integration.ts",
+        "test:integration:skipchecks": "jest  --watch  --no-cache --runInBand --config jest.config.integration.ts",
+        "test:skipchecks": "jest --passWithNoTests --watch  --no-cache --runInBand"
+    },
+    "author": "",
+    "license": "ISC",
+    "devDependencies": {
+        "@swc/core": "^1.3.55",
+        "@swc/jest": "^0.2.26",
+        "@types/dotenv": "^8.2.0",
+        "@types/jest": "^29.5.1",
+        "@types/node": "^18.18.12",
+        "@types/yup": "^0.32.0",
+        "dotenv": "^16.3.1",
+        "jest": "^29.5.0",
+        "rimraf": "^5.0.1",
+        "ts-jest": "^29.1.0",
+        "ttypescript": "^1.5.15",
+        "typescript": "^4.4.4",
+        "typescript-transform-paths": "^3.4.6"
+    },
+    "dependencies": {
+        "@types/express": "^4.17.21",
+        "axios": "^1.6.7",
+        "express": "^4.18.2",
+        "jest-mock-extended": "^3.0.4",
+        "node-fetch": "^3.3.2",
+        "reflect-metadata": "^0.1.13",
+        "ts-node-dev": "^2.0.0",
+        "tsconfig-paths": "^4.2.0"
+    }
+}

package/src/core/errors/custom-domain-error.ts

@@ -0,0 +1,12 @@
+import { DomainError } from "./domain-error";
+
+export class CustomDomainError<T> extends DomainError {
+    
+    errorName: T
+
+    constructor(name: T) {
+        super()
+        this.errorName = name
+        this.name = name as any
+    }
+}

package/src/core/errors/domain-error.ts

@@ -0,0 +1,7 @@
+
+export class DomainError extends Error {
+    constructor(message?: string) {
+        super(message)
+        this.name = this.constructor.name
+    }
+}

package/src/core/errors/index.ts

@@ -0,0 +1,2 @@
+export * from "./domain-error"
+export * from "./custom-domain-error"

package/src/core/logic/either.ts

@@ -0,0 +1,41 @@
+export class Failure<F, S> {
+  readonly value: F
+
+  constructor(value: F) {
+    this.value = value
+  }
+
+  isFailure(): this is Failure<F, S> {
+    return true
+  }
+
+  isSuccess(): this is Success<F, S> {
+    return false
+  }
+}
+
+export class Success<F, S> {
+  readonly value: S
+
+  constructor(value: S) {
+    this.value = value
+  }
+
+  isFailure(): this is Failure<F, S> {
+    return false
+  }
+
+  isSuccess(): this is Success<F, S> {
+    return true
+  }
+}
+
+export type Either<F, S> = Failure<F, S> | Success<F, S>
+
+export const failure = <F, S>(f?: F): Either<F, S> => {
+  return new Failure<F, S>(f!)
+}
+
+export const success = <F, S>(s?: S): Either<F, S> => {
+  return new Success<F, S>(s!)
+}

package/src/core/logic/index.ts

@@ -0,0 +1 @@
+export * from "./either"

package/src/index.ts

@@ -0,0 +1,18 @@
+import { WarpStore } from "./main"
+
+
+
+(async () => {
+
+    const warpstore = new WarpStore()
+    
+    const response = await warpstore.template.v1.getStoreInfo({
+        subDomain: "batata"
+    })
+
+    console.log(response.value)
+    if(response.isFailure()){
+        return
+    }
+})()
+

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from "./request-manager"

package/src/lib/request-manager.ts

@@ -0,0 +1,48 @@
+import { CustomDomainError, DomainError } from "@/core/errors";
+import { Either, failure, success } from "@/core/logic";
+import axios, { AxiosResponse } from "axios"
+
+const api = axios.create({
+    baseURL: 'http://localhost:5000',
+    timeout: 1000,
+    validateStatus: () => true
+})
+
+export class RequestManager {
+
+    static async makeRequest<TResponse, TError, >(path: string, httpInput: RequestManager.HttpInput = {} as any): Promise<Either<TError, TResponse>> {
+        const { body, headers, query, method } = httpInput
+
+        let response: AxiosResponse
+
+        if(method === "POST") {
+            response = await api.post(path, body, {
+                headers,
+                params: query
+            })
+        }else {
+            response = await api.get(path, {
+                headers,
+                params: query
+            })
+        }
+
+        if(response.status !== 200) {
+            return failure(new CustomDomainError(response.data?.error?.name)) as any
+        }
+        
+        return success(response.data) as any
+    }
+
+}
+
+export namespace RequestManager {
+
+
+    export type HttpInput = {
+        method: "GET" | "POST" 
+        body?: object
+        headers?: object
+        query?: object
+    }
+}

package/src/main.ts

@@ -0,0 +1,7 @@
+import { Template } from "./template";
+
+export class WarpStore {
+    template: Template = new Template()
+}
+
+

package/src/template/index.ts

@@ -0,0 +1,7 @@
+import { TemplateV1 } from "./versions";
+
+export class Template {
+
+    v1: TemplateV1 = new TemplateV1()
+
+}

package/src/template/versions/dtos.ts

@@ -0,0 +1,81 @@
+
+
+export  const  PlanEnum = {
+    BASIC: "BASIC",
+    SUPER: "SUPER",
+    ADVANCED: "ADVANCED"
+} as const
+
+export const PaymentMethodsEnum = {
+    MERCADO_PAGO: 'MERCADO_PAGO',
+    PIX: 'PIX',
+    STRIPE: 'STRIPE',
+} as const
+
+export type StoreThemeDto = {
+    id: string
+    title: string
+    description: string
+    logo: string
+    favicon: string
+    banner: string
+    subdomain: string
+    domain: string | undefined
+    currency: string
+    keywords: string
+    plan: keyof typeof PlanEnum
+    theme: {
+        primaryColor: string
+        secondaryColor: string
+        backgroundPrimaryColor: string
+        backgroundSecondaryColor: string
+    },
+    widgets: {
+        FEATURED_PRODUCT?: {
+            id: string
+            name: string
+            image: string
+            price: number
+        } 
+        DISCORD?: {
+            discordURL: string
+        }
+        ONLINE_PLAYERS?: {
+            ip: string
+            port: number
+        }
+    },
+    visualEffects: {
+        SNOW_FLAKE?: { 
+            color: string, 
+            radius: number, 
+            snowFlakeCount: number 
+        }
+    },
+    socialMedia: {
+        instagram?: string
+        tiktok?: string
+        youtube?: string
+        discord?: string
+    },
+    paymentMethods: keyof typeof PaymentMethodsEnum[]
+    
+    categories: {
+        id: string
+        title: string
+        slug: string
+        description: string   
+    }[]
+}
+
+export type ProductInfoDto = {
+    products: {
+        id: string
+        name: string
+        description: string
+        price: number
+        image: string
+    }
+    quantityReturned: number
+    totalQuantity: number
+}

package/src/template/versions/errors/errors.ts

@@ -0,0 +1,12 @@
+import { CustomDomainError } from "@/core/errors";
+
+type Error = "NoParamsProvidedError" |  "StoreNotFoundError" | "InvalidRequestError"
+
+export class GetStoreInfoError extends CustomDomainError<Error> {
+
+    constructor(name: Error) {
+        super(name)
+    }
+}
+
+

package/src/template/versions/index.ts

@@ -0,0 +1 @@
+export * from "./v1"

package/src/template/versions/v1.ts

@@ -0,0 +1,37 @@
+import { DomainError } from "@/core/errors"
+import { Either, success } from "@/core/logic"
+import { ProductInfoDto, StoreThemeDto } from "./dtos"
+import { RequestManager } from "@/lib"
+import { GetStoreInfoError } from "./errors/errors"
+
+export class TemplateV1 {
+
+    async getStoreInfo(input: TemplateV1.GetStoreInfoInputDto): Promise<Either<GetStoreInfoError, StoreThemeDto>>{
+        return await RequestManager.makeRequest<StoreThemeDto, GetStoreInfoError>("/template/v1/store-info", {
+            method: "GET",
+            query: input
+        })
+    }
+
+    async getProducts(input: TemplateV1.GetProductsInputDto): Promise<Either<DomainError, ProductInfoDto>>{
+        return await RequestManager.makeRequest<ProductInfoDto, DomainError>("/template/v1/products", {
+            method: "GET",
+            query: input
+        })
+    }
+}
+
+
+export namespace TemplateV1 {
+
+    export type GetProductsInputDto = {
+        categoryId: string
+        limit?: number
+        skip?: number
+    }
+
+    export type GetStoreInfoInputDto = {
+        subDomain?: string
+        domain?: string
+    }
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  
+    "compilerOptions": {
+      "experimentalDecorators": true,
+      "declaration": true,
+      "declarationMap": true,
+      "composite": true,
+      "target": "es2021",
+      "module": "commonjs",
+      "rootDir": ".",
+      "moduleResolution": "node",
+      "baseUrl": "./src",
+      "noImplicitAny": true,
+      "paths": {
+        "@/*": [
+          "*"
+        ]
+      },
+      "plugins": [
+        {
+          "transform": "typescript-transform-paths"
+        },
+        {
+          "transform": "typescript-transform-paths",
+          "afterDeclarations": true
+        }
+      ],
+      "outDir": "./dist",
+      "forceConsistentCasingInFileNames": true,
+      "strict": true,
+      "skipLibCheck": true
+    }
+  }