kodzero-front-sdk-alfa 0.0.4 → 0.0.5

package/src/model/BaseModel.ts

@@ -1,9 +1,10 @@
 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.js";
+import BaseModelSchema from "../schemas/baseModel.js";
+import validateApiResponse from "../utils/validateApiResponse.js";
 
 export interface ModelOptions {
     host: string
@@ -19,7 +20,7 @@ class BaseModel<T extends { _id?: string }> {
     collection: string
     modelData: T = {} as T
     schema?: typeof Schema
-    api: typeof FluidFetch
+    apiClient: typeof FluidFetch
 
     id: string | null;
 
@@ -27,13 +28,13 @@ class BaseModel<T extends { _id?: string }> {
     static collection: string
     static api: typeof FluidFetch
 
-    constructor(options: ModelOptions, api: typeof FluidFetch) {
+    constructor(options: ModelOptions, apiClient: typeof FluidFetch) {
         BaseModelSchema.validateOrThrow(options);
 
         this.host = options.host
         this.collection = options.collection
         this.schema = options.schema ? new Schema({...options.schema}) : null
-        this.api = api
+        this.apiClient = apiClient
         this.id = null;
     }
 
@@ -147,7 +148,7 @@ class BaseModel<T extends { _id?: string }> {
 
         const updateUrl = buildURL(this.host, this.collection, this.id)
        
-        const response = await this.api.patch(updateUrl, this._dataWithoutId())
+        const response = await this.apiClient.patch(updateUrl, this._dataWithoutId())
             .headers({ 'Content-Type': 'application/json' });
 
         await this._handleApiError(response);        
@@ -167,8 +168,7 @@ class BaseModel<T extends { _id?: string }> {
         }
 
         const deleteUrl = buildURL(this.host, this.collection, this.id);
-
-        const response = await this.api.delete(deleteUrl);
+        const response = await this.apiClient.delete(deleteUrl);
         await this._handleApiError(response);
 
         this._setId(null);
@@ -182,13 +182,11 @@ class BaseModel<T extends { _id?: string }> {
      */
     async create(): Promise<T> {
         const createUrl = buildURL(this.host, this.collection)
-        
-        const response = await this.api.post(createUrl, this._dataWithoutId())
+        const response = await this.apiClient.post(createUrl, this._dataWithoutId())
             .headers({ 'Content-Type': 'application/json' });
-
         await this._handleApiError(response);
-        const json = await response.json();
         
+        const json = await response.json();
         this._setModelData(json.result);
 
         return this.modelData

package/src/model/PaginatedResult.ts

@@ -0,0 +1,81 @@
+import { FindManyOptions } from "./createModel.js"
+
+interface PaginationState {
+    skip: number,
+    limit: number,
+    page: number,
+    total: number,
+    totalPages: number,
+    left: number
+}
+
+interface PaginationResultInput<T> {
+    data: T[],
+    state: PaginationState,
+    options: FindManyOptions | {},
+    findManyFunction: Function
+}
+
+class PaginatedResult<T = {}> {
+    state: PaginationState
+    data: Array<T>
+    options: FindManyOptions | {}
+    private findManyFunction: Function
+
+    constructor(input: PaginationResultInput<T>) {
+        const {findManyFunction, state, data, options} = input
+
+        this.options = options
+        this.findManyFunction = findManyFunction
+
+        this.state = {
+            skip: state.skip || 0,
+            limit: state.limit || 0,
+            page: state.page || 0,
+            total: state.total || 0,
+            totalPages: state.totalPages || 0,
+            left: state.left || 0
+        }
+
+        this.data = data
+    }
+
+    async next(): Promise<PaginatedResult<T>> {
+        this.state.page++;
+
+        const result = await this.findManyFunction(this.options, this.state.page, this.state.limit);
+        this.data = result.data;
+
+        return this;
+    }
+
+    async previous(): Promise<PaginatedResult<T>> {
+        if (this.state.page === 1) throw new Error('Page cannot be lower than 1')
+
+        this.state.page--;
+        const result = await this.findManyFunction(this.options, this.state.page, this.state.limit);
+        this.data = result.data
+
+        return this;
+    }
+
+    async page(pageNumber: number) {
+        if (pageNumber < 1) throw new Error('Page cannot be lower than 1')
+        
+        this.state.page = pageNumber
+        const result = this.findManyFunction(this.options, this.state.page, this.state.limit);
+        this.data = result.data
+        
+        return this;
+    }
+
+    hasNext(): boolean {
+        return this.state.page < this.state.totalPages
+    }
+
+    hasPrevious(): boolean {
+        return this.state.page > 1
+    }
+}
+
+export default PaginatedResult

package/src/model/createModel.ts

@@ -4,6 +4,7 @@ import {KzResponseFindMany } from '../types/responses.js'
 import validateApiResponse from '../utils/validateApiResponse.js'
 import buildURL from '../utils/buildURL.js'
 import constants from './constants.js'
+import PaginatedResult from './PaginatedResult.js'
 
 export interface FindManyOptions {
     page: number
@@ -19,11 +20,11 @@ export interface FindManyOptions {
 const createModel = <
     T extends { _id?: string },
     M = {}
->(options: ModelOptions, api: typeof FluidFetch) => {
+>(options: ModelOptions, apiClient: typeof FluidFetch) => {
     const Model = class extends BaseModel<T> {
         static host = options.host
         static collection = options.collection
-        static api = api
+        static apiClient = apiClient
 
         static async _handleApiError(response: Response) {
             return validateApiResponse(response)
@@ -62,7 +63,7 @@ const createModel = <
 
             const getUrl = buildURL(Model.host, Model.collection, id)
 
-            const response = await Model.api.get(getUrl);
+            const response = await Model.apiClient.get(getUrl);
             await Model._handleApiError(response);
 
             const data = await response.json();
@@ -74,18 +75,40 @@ const createModel = <
             
             const params = {...options} as Record<string, any>;
 
-            const response = await Model.api.get(getUrl).params(params);
+            const response = await Model.apiClient.get(getUrl).params(params);
             await Model._handleApiError(response);
 
             const data: KzResponseFindMany<T> = await response.json();
             return data.result.found;
         }
 
+        static async findManyPaginated(
+            options: FindManyOptions | {} = {},
+            page: number = 1,
+            perPage: number = 25
+        ): Promise<any> {
+            if (!page || page < 1) throw new Error('Page number must be greater than 0');
+
+            const getUrl = buildURL(Model.host, Model.collection)
+            const params = {...options, page, perPage} as Record<string, any>;
+            const response = await Model.apiClient.get(getUrl).params(params);
+            await Model._handleApiError(response);
+
+            const data: KzResponseFindMany<T> = await response.json();
+
+            return new PaginatedResult({
+                data: data.result.found,
+                state: data.result,
+                options,
+                findManyFunction: Model.findManyPaginated
+            })
+        }
+
         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)
+            const response = await Model.apiClient.post(createUrl)
                 .body(dataWithoutId)
                 .headers({
                     'Content-Type': 'application/json'
@@ -109,7 +132,7 @@ const createModel = <
                 return rest;
             });
             
-            const response = await Model.api.post(createUrl)
+            const response = await Model.apiClient.post(createUrl)
                 .body(dataWithoutId)
                 .headers({
                     'Content-Type': 'application/json'
@@ -127,7 +150,7 @@ const createModel = <
             
             const updateUrl = buildURL(Model.host, Model.collection, id)
             const {_id, ...dataWithoutId} = data as Partial<T> & {_id?: string};
-            const response = await Model.api.patch(updateUrl)
+            const response = await Model.apiClient.patch(updateUrl)
                 .body(dataWithoutId)
                 .headers({ 'Content-Type': 'application/json' });
 
@@ -148,7 +171,7 @@ const createModel = <
 
             const updateUrl = buildURL(Model.host, Model.collection) + '/batch'
 
-            const response = await Model.api.patch(updateUrl)
+            const response = await Model.apiClient.patch(updateUrl)
                 .body(updates)
                 .headers({ 'Content-Type': 'application/json' });
 
@@ -163,7 +186,7 @@ const createModel = <
 
             const deleteUrl = buildURL(Model.host, Model.collection, id)
             
-            const response = await Model.api.delete(deleteUrl);
+            const response = await Model.apiClient.delete(deleteUrl);
             await Model._handleApiError(response);
             
             const json = await response.json();
@@ -171,13 +194,11 @@ const createModel = <
         }
 
         static async deleteMany(ids: string[]): Promise<Record<string, boolean>> {
-            if (!ids || ids.length === 0) {
-                throw new Error(constants.RequiresIdsArray);
-            }
+            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)
+            const response = await Model.apiClient.delete(deleteUrl)
                 .body({ ids })
                 .headers({ 'Content-Type': 'application/json' });
 
@@ -188,13 +209,15 @@ const createModel = <
         }
 
         static async distinct(fields: string[], filter?: Record<string, any>): Promise<string[]> {
+            throw new Error('Distinct method is disabled in this SDK version'); // temporary disable
+
             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)
+            const response = await Model.apiClient.get(distinctUrl)
                 .params({ fields: fields.join(','), filter: filter ? JSON.stringify(filter) : undefined })
                 .headers({ 'Content-Type': 'application/json' });
 
@@ -205,7 +228,7 @@ const createModel = <
         }
 
         constructor(data: T) {
-            super(options, api)
+            super(options, apiClient)
 
             this.modelData = {...data, _id: null}
             this.id = null;
@@ -220,6 +243,7 @@ const createModel = <
         registerMethod<K extends keyof M>(name: K, fn: M[K]): void;
         find(id: string): Promise<T>;
         findMany(options?: FindManyOptions | {}): Promise<T[]>;
+        findManyPaginated(options?: FindManyOptions | {}, page?: number, perPage?: number): Promise<PaginatedResult<T>>;
         create(data: T): Promise<T>;
         createMany(data: T[]): Promise<T[]>;
         update(id: string, data: Partial<T>): Promise<T>;

package/src/schemas/baseAuth.ts

@@ -1,6 +1,7 @@
 import Schema from 'validno'
 import KodzeroValidationError from '../errors/KodzeroValidationError.js';
 
+// TODO: сделать класс конструктор для таких реализаций?
 class BaseAuthSchema {
     // Validation schema for BaseAuth class constructor options
     static schema = new Schema({
@@ -16,7 +17,7 @@ class BaseAuthSchema {
 
         if (!validation.ok) {
             throw new KodzeroValidationError(
-                'Invalid auth options: ' + validation.failed.join(', '),
+                'Invalid auth options: ' + validation.failed.join(', '),  // TODO: to constants
                 validation.errors
             );
         }

package/src/schemas/baseModel.ts

@@ -23,7 +23,7 @@ class BaseModelSchema {
 
         if (!validation.ok) {
             throw new KodzeroValidationError(
-                'Invalid model options: ' + validation.failed.join(', '),
+                'Invalid model options: ' + validation.failed.join(', '),   // TODO: to constants
                 validation.errors
             );
         }

package/src/tsconfig.json

@@ -11,7 +11,7 @@
       // "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. */
+      "target": "esnext",                                  /* 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. */
@@ -25,9 +25,9 @@
       // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
   
       /* Modules */
-      "module": "ES2022",                                /* Specify what module code is generated. */
+      "module": "nodenext",                                /* 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. */
+      "moduleResolution": "nodenext",                       /* 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. */
@@ -70,11 +70,10 @@
   
       /* 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. */
+      "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. */
@@ -95,9 +94,11 @@
       // "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. */
-    }
+    },
+    "exclude": [
+      "**/*.test.ts",
+      "**/__tests__/**"
+    ]
   }

package/src/utils/buildURL.ts

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

package/dist/fetcher/InterceptorManager.d.ts

@@ -1,9 +0,0 @@
-declare class MiddlewareManager<T> {
-    private handlers;
-    private idCounter;
-    use(fulfilled: (value: T) => Promise<T> | T, rejected?: (error: any) => any): number;
-    eject(id: number): void;
-    clear(): void;
-    runMiddlewares(value: T): Promise<T>;
-}
-export default MiddlewareManager;

package/dist/fetcher/InterceptorManager.js

@@ -1,42 +0,0 @@
-class MiddlewareManager {
-    constructor() {
-        this.handlers = [];
-        this.idCounter = 0;
-    }
-    use(fulfilled, rejected) {
-        const id = this.idCounter++;
-        this.handlers.push({
-            fulfilled,
-            rejected,
-            id
-        });
-        return id;
-    }
-    eject(id) {
-        const index = this.handlers.findIndex(handler => handler.id === id);
-        if (index !== -1) {
-            this.handlers.splice(index, 1);
-        }
-    }
-    clear() {
-        this.handlers = [];
-    }
-    async runMiddlewares(value) {
-        let result = value;
-        for (const handler of this.handlers) {
-            try {
-                result = await handler.fulfilled(result);
-            }
-            catch (error) {
-                if (handler.rejected) {
-                    result = await handler.rejected(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        return result;
-    }
-}
-export default MiddlewareManager;

package/dist/fetcher/MiddlewareManager.d.ts

@@ -1,9 +0,0 @@
-declare class MiddlewareManager<T> {
-    private handlers;
-    private idCounter;
-    use(fulfilled: (value: T) => Promise<T> | T, rejected?: (error: any) => any): number;
-    eject(id: number): void;
-    clear(): void;
-    runMiddlewares(value: T): Promise<T>;
-}
-export default MiddlewareManager;

package/dist/fetcher/MiddlewareManager.js

@@ -1,42 +0,0 @@
-class MiddlewareManager {
-    constructor() {
-        this.handlers = [];
-        this.idCounter = 0;
-    }
-    use(fulfilled, rejected) {
-        const id = this.idCounter++;
-        this.handlers.push({
-            fulfilled,
-            rejected,
-            id
-        });
-        return id;
-    }
-    eject(id) {
-        const index = this.handlers.findIndex(handler => handler.id === id);
-        if (index !== -1) {
-            this.handlers.splice(index, 1);
-        }
-    }
-    clear() {
-        this.handlers = [];
-    }
-    async runMiddlewares(value) {
-        let result = value;
-        for (const handler of this.handlers) {
-            try {
-                result = await handler.fulfilled(result);
-            }
-            catch (error) {
-                if (handler.rejected) {
-                    result = await handler.rejected(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        return result;
-    }
-}
-export default MiddlewareManager;

package/dist/fetcher/index.d.ts

@@ -1,77 +0,0 @@
-import MiddlewareManager from './MiddlewareManager.js';
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
-declare class TimeoutError extends Error {
-    constructor(message: string);
-}
-interface RequestConfig {
-    headers?: Record<string, string>;
-    params?: Record<string, string | number | boolean>;
-    cache?: boolean | number;
-    timeout?: number;
-}
-interface RequestMiddleware {
-    (request: Request): Promise<Request> | Request;
-}
-interface ResponseMiddleware {
-    (response: Response): Promise<Response> | Response;
-}
-interface Middlewares {
-    request: RequestMiddleware[];
-    response: ResponseMiddleware[];
-}
-interface Request {
-    method: HttpMethod;
-    url: string;
-    data: any | null;
-    headers: Record<string, string>;
-    params: Record<string, string | number | boolean>;
-    cache?: boolean | number;
-    timeout?: number;
-    abortController: AbortController;
-}
-declare class FluidFetch {
-    private cache;
-    private pendingRequests;
-    middlewares: {
-        request: MiddlewareManager<Request>;
-        response: MiddlewareManager<Response>;
-    };
-    interceptors: Middlewares & {
-        request: MiddlewareManager<Request>;
-        response: MiddlewareManager<Response>;
-    };
-    constructor();
-    get<T = any>(url: string, config?: RequestConfig): FluidFetchRequest<T>;
-    post<T = any>(url: string, data?: any, config?: RequestConfig): FluidFetchRequest<T>;
-    put<T = any>(url: string, data?: any, config?: RequestConfig): FluidFetchRequest<T>;
-    delete<T = any>(url: string, config?: RequestConfig): FluidFetchRequest<T>;
-    private _createRequest;
-    _getCacheKey(request: Request): string;
-    _buildUrl(url: string, params: Record<string, string | number | boolean> | undefined): string;
-    getCachedResponse(cacheKey: string): Response | undefined;
-    getPendingRequest(cacheKey: string): AbortController | undefined;
-    registerPendingRequest(cacheKey: string, controller: AbortController): void;
-    removePendingRequest(cacheKey: string): void;
-    cacheResponse(cacheKey: string, response: Response, ttl?: number): void;
-    clearRequestMiddlewares(): void;
-    clearResponseMiddlewares(): void;
-    clearRequestInterceptors(): void;
-    clearResponseInterceptors(): void;
-}
-declare class FluidFetchRequest<T = any> implements PromiseLike<Response> {
-    private fluidFetch;
-    private request;
-    private promise;
-    constructor(fluidFetch: FluidFetch, request: Request);
-    headers(headers: Record<string, string>): FluidFetchRequest<T>;
-    params(params: Record<string, string | number | boolean>): FluidFetchRequest<T>;
-    body(data: any): FluidFetchRequest<T>;
-    cache(ttl: boolean | number): FluidFetchRequest<T>;
-    timeout(ms: number): FluidFetchRequest<T>;
-    cancel(): FluidFetchRequest<T>;
-    then<TResult1 = Response, TResult2 = never>(onFulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): PromiseLike<Response | TResult>;
-    private _executeRequest;
-}
-export { TimeoutError, MiddlewareManager, RequestMiddleware, ResponseMiddleware };
-export default FluidFetch;