kodzero-front-sdk-alfa 0.0.2

package/src/model/BaseModel.ts

@@ -0,0 +1,210 @@
+import Schema from "validno";
+import FluidFetch from "fluid-fetch";
+
+import constants from "./constants.js";
+import validateApiResponse from "../utils/validateApiResponse.js";
+import BaseModelSchema from "../schemas/baseModel.js";
+import buildURL from "../utils/buildURL_rename.js";
+
+export interface ModelOptions {
+    host: string
+    collection: string
+    schema?: typeof Schema
+}
+
+/**
+ * Base model constructor that expose main methods to work with user-created model
+ */
+class BaseModel<T extends { _id?: string }> {
+    host: string
+    collection: string
+    modelData: T = {} as T
+    schema?: typeof Schema
+    api: typeof FluidFetch
+
+    id: string | null;
+
+    static url: string
+    static collection: string
+    static api: typeof FluidFetch
+
+    constructor(options: ModelOptions, api: typeof FluidFetch) {
+        BaseModelSchema.validateOrThrow(options);
+
+        this.host = options.host
+        this.collection = options.collection
+        this.schema = options.schema
+        this.api = api
+        this.id = null;
+    }
+
+    /**
+     * Private
+     * Setter for this.id
+     */
+    _setId = (id: string | null) => {
+        this.id = id
+    }
+
+    /**
+     * Private
+     * Setter for this.modelData. Also sets this.id if it is present
+     */
+    _setModelData = (data: T) => {
+        this.modelData = data;
+        this._setId(data?._id || null);
+    }
+
+    /**
+     * Private
+     * Links to API error handler
+     */
+    _handleApiError(response: Response) {
+        return validateApiResponse(response)
+    }
+
+    /**
+     * Getter for model's data (this.modelData)
+     */
+    data(): T {
+        return this.modelData
+    }
+
+    /**
+     * Private
+     * Getter for model's data (this.modelData) excluding "_id" field
+     * Used to 
+     */
+    _dataWithoutId(): Omit<T, "_id"> | {} {
+        if (typeof this.modelData === 'object' && this.modelData !== null && '_id' in this.modelData) {
+            const { _id, ...dataWithoutId } = this.modelData as T;
+            return dataWithoutId;
+        }
+
+        return this.modelData;
+    }
+
+    /**
+     * Private
+     * Sets nested keys of this.modelData by the path
+     * Path example: 'key.level2.level3'
+     */
+    _setNested(key: string, value: any) {
+        const keys = key.split('.');
+
+
+        let obj = this.modelData;
+        while (keys.length > 1) {
+            const k = keys.shift()!;
+            // @ts-ignore
+            if (!(k in obj)) obj[k] = {};
+            // @ts-ignore
+            obj = obj[k];
+        }
+        // @ts-ignore
+        obj[keys[0]] = value;
+
+        return this.modelData
+    }
+
+    /**
+     * Setter for model's data (this.modelData)
+     */
+    set(data: Record<string, any> | string, value?: any) {
+        if (typeof data === 'string' && value !== undefined) {
+            this._setNested(data, value);
+        } else if (typeof data === 'object') {
+            Object.entries(data).forEach(([key, value]) => {
+                this._setNested(key, value);
+            });
+        }
+
+        return this.modelData;
+    }
+
+    /**
+     * Validates model's data against it's schema
+     */
+    validate(): {ok: boolean, errors: string[], joinErrors: () => string} {
+        const schema = this.schema;
+
+        if (!schema) {
+            throw new Error(constants.NoSchema);
+        }
+
+        const keysToValidate = Object.keys(this.schema.definition).filter(k => k !== '_id')
+        const validationResult = schema.validate(this._dataWithoutId(), keysToValidate);
+
+        return validationResult
+    }
+
+    /**
+     * Sends patch request to update document data by it's _id
+     */
+    async update(): Promise<T> {
+        if (!this.id) {
+            throw new Error(constants.RequiresId);
+        }
+
+        const updateUrl = buildURL(this.host, this.collection, this.id)
+       
+        const response = await this.api.patch(updateUrl, this._dataWithoutId())
+            .headers({ 'Content-Type': 'application/json' });
+
+        await this._handleApiError(response);        
+        const json = await response.json();
+        
+        this._setModelData(json.result);
+
+        return this.modelData
+    }
+
+    /**
+     * Sends delete request to delete document by it's _id
+     */
+    async delete(): Promise<boolean> {
+        if (!this.id) {
+            throw new Error(constants.RequiresId);
+        }
+
+        const deleteUrl = buildURL(this.host, this.collection, this.id);
+
+        const response = await this.api.delete(deleteUrl);
+        await this._handleApiError(response);
+
+        this._setId(null);
+        this.modelData = {} as T;
+
+        return true;
+    }
+
+    /**
+     * Sends post request to insert document into the collection
+     */
+    async create(): Promise<T> {
+        const createUrl = buildURL(this.host, this.collection)
+        
+        const response = await this.api.post(createUrl, this._dataWithoutId())
+            .headers({ 'Content-Type': 'application/json' });
+
+        await this._handleApiError(response);
+        const json = await response.json();
+        
+        this._setModelData(json.result);
+
+        return this.modelData
+    }
+
+    /**
+     * Updates document or inserts it depending on presense of _id (this.id)
+     */
+    async save(): Promise<T> {
+        if (this.id) {
+            return this.update();
+        } else {
+            return this.create();
+        }
+    }
+}
+
+export default BaseModel

package/src/model/constants.ts

@@ -0,0 +1,7 @@
+export default {
+    NoSchema: 'No schema defined for validation',
+    RequiresId: 'Method requires model id',
+    DataTypeNotArray: 'Data must be a non-empty array',
+    RequiresIdsArray: 'Method requires array of ids',
+    DistinctRequiresFieldsArray: 'Distinct methods requires array of fields'
+}

package/src/model/createModel.ts

@@ -0,0 +1,237 @@
+import FluidFetch from 'fluid-fetch'
+import BaseModel, { ModelOptions } from './BaseModel.js'
+import {KzResponseFindMany } from '../types/responses.js'
+import validateApiResponse from '../utils/validateApiResponse.js'
+import buildURL from '../utils/buildURL_rename.js'
+import constants from './constants.js'
+
+export interface FindManyOptions {
+    page: number
+    perPage: number
+    search?: string
+    sort?: string
+    fields?: string[]
+}
+
+/**
+ * Creates custom model with the specified schema, API options, etc.
+ */
+const createModel = <
+    T extends { _id?: string },
+    M = {}
+>(options: ModelOptions, api: typeof FluidFetch) => {
+    const Model = class extends BaseModel<T> {
+        static host = options.host
+        static collection = options.collection
+        static api = api
+
+        static async _handleApiError(response: Response) {
+            return validateApiResponse(response)
+        }
+
+        // ** Model methods **
+        static async get(id: string): Promise<InstanceType<typeof Model>> {
+            if (!id) throw new Error(constants.RequiresId)
+            
+            const getUrl = buildURL(Model.host, Model.collection, id)
+            
+            const response = await Model.api.get(getUrl);
+            await Model._handleApiError(response);
+
+            const json = await response.json();
+            
+            return new Model(json.result);
+        }
+
+        /**
+         * Adds custom method to Model
+         * 
+         * TS support: pass interfaces for both data and custom methods:
+         * Example: 
+         * interface Dog { name: string }
+         * interface DogMethods { greet: () => `Woof! ${this.data().name}`}
+         * "createModel<Dog, DogMethods>(...)"
+         */
+        static registerMethod<K extends keyof M>(name: K, fn: M[K]) {
+            (Model.prototype as any)[name] = fn;
+        }
+
+        // ** Collection methods **
+        static async find(id: string): Promise<T> {
+            if (!id) throw new Error(constants.RequiresId);
+
+            const getUrl = buildURL(Model.host, Model.collection, id)
+
+            const response = await Model.api.get(getUrl);
+            await Model._handleApiError(response);
+
+            const data = await response.json();
+            return data.result;
+        }
+
+        static async findMany(options?: FindManyOptions | {}): Promise<T[]> {
+            const getUrl = buildURL(Model.host, Model.collection)
+            
+            const params = {...options} as Record<string, any>;
+
+            const response = await Model.api.get(getUrl).params(params);
+            await Model._handleApiError(response);
+
+            const data: KzResponseFindMany<T> = await response.json();
+            return data.result.found;
+        }
+
+        static async create(data: T): Promise<T> {
+            const createUrl = buildURL(Model.host, Model.collection)
+            const {_id, ...dataWithoutId} = data as T & {_id?: string};
+
+            const response = await Model.api.post(createUrl)
+                .body(dataWithoutId)
+                .headers({
+                    'Content-Type': 'application/json'
+                })
+
+            await Model._handleApiError(response);
+
+            const json = await response.json();
+            return json.result
+        }
+
+        static async createMany(records: T[]): Promise<T[]> {
+            if (!records || !Array.isArray(records) || !records.length) {
+                throw new Error(constants.DataTypeNotArray)
+            }
+
+            const createUrl = buildURL(Model.host, Model.collection) + '/batch'
+
+            const dataWithoutId = records.map(item => {
+                const {_id, ...rest} = item as T & {_id?: string};
+                return rest;
+            });
+            
+            const response = await Model.api.post(createUrl)
+                .body(dataWithoutId)
+                .headers({
+                    'Content-Type': 'application/json'
+                })
+            await Model._handleApiError(response);
+
+            const json = await response.json();
+            return json.result
+        }
+
+        static async update(id: string, data: Partial<T>): Promise<T> {
+            if (!id) {
+                throw new Error(constants.RequiresId);
+            }
+            
+            const updateUrl = buildURL(Model.host, Model.collection, id)
+            const {_id, ...dataWithoutId} = data as Partial<T> & {_id?: string};
+            const response = await Model.api.patch(updateUrl)
+                .body(dataWithoutId)
+                .headers({ 'Content-Type': 'application/json' });
+
+            await Model._handleApiError(response);        
+            const json = await response.json();
+            
+            return json.result;
+        }
+
+        static async updateMany(updates: Partial<T>[]): Promise<T[]> {
+            if (!updates || !Array.isArray(updates) || updates.length === 0) {
+                throw new Error(constants.DataTypeNotArray);
+            }
+
+            if (updates.some(update => !update._id)) {
+                throw new Error("All updates must have an _id");
+            }
+
+            const updateUrl = buildURL(Model.host, Model.collection) + '/batch'
+
+            const response = await Model.api.patch(updateUrl)
+                .body(updates)
+                .headers({ 'Content-Type': 'application/json' });
+
+            await Model._handleApiError(response);        
+            const json = await response.json();
+            
+            return json.result;
+        }
+
+        static async delete(id: string): Promise<boolean> {
+            if (!id) throw new Error(constants.RequiresId);
+
+            const deleteUrl = buildURL(Model.host, Model.collection, id)
+            
+            const response = await Model.api.delete(deleteUrl);
+            await Model._handleApiError(response);
+            
+            const json = await response.json();
+            return json.result;
+        }
+
+        static async deleteMany(ids: string[]): Promise<Record<string, boolean>> {
+            if (!ids || ids.length === 0) {
+                throw new Error(constants.RequiresIdsArray);
+            }
+
+            const deleteUrl = buildURL(Model.host, Model.collection) + '/batch'
+            
+            const response = await Model.api.delete(deleteUrl)
+                .body({ ids })
+                .headers({ 'Content-Type': 'application/json' });
+
+            await Model._handleApiError(response);
+
+            const json = await response.json();
+            return json.result;
+        }
+
+        static async distinct(fields: string[], filter?: Record<string, any>): Promise<string[]> {
+            if (!fields || fields.length === 0) {
+                throw new Error(constants.DistinctRequiresFieldsArray);
+            }
+
+            const distinctUrl = buildURL(Model.host, Model.collection, 'distinct')
+
+            const response = await Model.api.post(distinctUrl)
+                .params({ fields: fields.join(','), filter: filter ? JSON.stringify(filter) : undefined })
+                .headers({ 'Content-Type': 'application/json' });
+
+            await Model._handleApiError(response);
+
+            const json = await response.json();
+            return json.result;
+        }
+
+        constructor(data: T) {
+            super(options, api)
+
+            this.modelData = {...data, _id: null}
+            this.id = null;
+        }
+    }
+
+    // Return type: ModelConstructor<T, M>
+    type ModelInstance = BaseModel<T> & M;
+    type Model = {
+        new(data: T): ModelInstance;
+        get(id: string): Promise<ModelInstance>;
+        registerMethod<K extends keyof M>(name: K, fn: M[K]): void;
+        find(id: string): Promise<T>;
+        findMany(options?: FindManyOptions | {}): Promise<T[]>;
+        create(data: T): Promise<T>;
+        createMany(data: T[]): Promise<T[]>;
+        update(id: string, data: Partial<T>): Promise<T>;
+        updateMany(updates: Partial<T>[]): Promise<T[]>;
+        delete(id: string): Promise<boolean>;
+        deleteMany(ids: string[]): Promise<Record<string, boolean>>;
+        distinct(fields: string[], filter?: Record<string, any>): Promise<string[]>;
+        host: string;
+        collection: string;
+    };
+
+    return Model as unknown as Model;
+}
+
+export default createModel

package/src/model/index.ts

@@ -0,0 +1,12 @@
+import BaseModel from "./BaseModel.js";
+import createModel from "./createModel.js";
+import KodzeroApiError from "../errors/KodzeroApiError.js";
+
+export {
+    // Models
+    createModel,
+    BaseModel,
+
+    // Errors
+    KodzeroApiError
+}

package/src/schemas/baseAuth.ts

@@ -0,0 +1,28 @@
+import Schema from 'validno'
+import KodzeroValidationError from '../errors/KodzeroValidationError.js';
+
+class BaseAuthSchema {
+    // Validation schema for BaseAuth class constructor options
+    static schema = new Schema({
+        host: {
+            type: String
+        }
+    })
+
+    static validate = (options: Record<string, any>) => BaseAuthSchema.schema.validate(options);
+
+    static validateOrThrow = (options: Record<string, any>) => {
+        const validation = BaseAuthSchema.schema.validate(options);
+
+        if (!validation.ok) {
+            throw new KodzeroValidationError(
+                'Invalid auth options: ' + validation.failed.join(', '),
+                validation.errors
+            );
+        }
+
+        return true
+    }
+}
+
+export default BaseAuthSchema;

package/src/schemas/baseModel.ts

@@ -0,0 +1,35 @@
+import Schema from 'validno'
+import KodzeroValidationError from '../errors/KodzeroValidationError.js';
+
+class BaseModelSchema {
+    // Validation schema for BaseModel class constructor options
+    static schema = new Schema({
+        host: {
+            type: String
+        },
+        collection: {
+            type: String
+        },
+        schema: {
+            type: Schema,
+            required: false
+        }
+    })
+
+    static validate = (options: Record<string, any>) => BaseModelSchema.schema.validate(options);
+
+    static validateOrThrow = (options: Record<string, any>) => {
+        const validation = BaseModelSchema.schema.validate(options);
+
+        if (!validation.ok) {
+            throw new KodzeroValidationError(
+                'Invalid model options: ' + validation.failed.join(', '),
+                validation.errors
+            );
+        }
+
+        return true
+    }
+}
+
+export default BaseModelSchema;

package/src/tsconfig.json

@@ -0,0 +1,103 @@
+{
+    "compilerOptions": {
+      /* Visit https://aka.ms/tsconfig to read more about this file */
+  
+      /* Projects */
+      // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+      // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+      // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+      // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+      // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+      // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+  
+      /* Language and Environment */
+      "target": "ES2017",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+      // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+      // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+      // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+      // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+      // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+      // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+      // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+      // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+      // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+      // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+      // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+  
+      /* Modules */
+      "module": "ES2022",                                /* Specify what module code is generated. */
+      "rootDir": "../src/",                                  /* Specify the root folder within your source files. */
+      "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+      // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+      // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+      // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+      // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+      // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+      // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+      // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+      // "resolveJsonModule": true,                        /* Enable importing .json files. */
+      // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+  
+      /* JavaScript Support */
+      "allowJs": false,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+      // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+      // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+  
+      /* Emit */
+      "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+      // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+      // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+      "sourceMap": false,                                /* Create source map files for emitted JavaScript files. */
+      // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+      "outDir": "../dist/",                                   /* Specify an output folder for all emitted files. */
+      "removeComments": true,                           /* Disable emitting comments. */
+      // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+      // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+      // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+      // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+      // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+      // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+      // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+      // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+      // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+      // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+      // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+      // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+      // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+      // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+      // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+      // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+  
+      /* Interop Constraints */
+      // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+      // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+      "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+      // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+      "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+  
+      /* Type Checking */
+      "strict": true,                                      /* Enable all strict type-checking options. */
+      // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+      // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+      // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+      // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+      // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+      // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+      // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+      // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+      // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+      // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+      // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+      // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+      // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+      // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+      // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+      // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+      // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+      // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+  
+      /* Completeness */
+      // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+      "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    }
+  }

package/src/types/module.d.ts

@@ -0,0 +1,2 @@
+declare module 'validno'
+declare module 'fluid-fetch'

package/src/types/responses.ts

@@ -0,0 +1,14 @@
+export interface KzResponse<T = any> {
+    ok: boolean
+    result: T
+}
+
+export interface KzResponseFindMany<T = any> extends KzResponse<{
+    skip: number,
+    limit: number,
+    page: number,
+    total: number,
+    totalPages: number,
+    left: number,
+    found: T[],
+}> {}

package/src/utils/buildURL_rename.ts

@@ -0,0 +1,8 @@
+const buildURL = (baseUrl: string, collection: string, id?: string): string => {
+    let url = `${baseUrl}/${collection}`;
+    if (id) url += `/${id}`;
+    
+    return url.replace(/\/+/g, '/').replace(':/', '://');
+}
+
+export default buildURL;