kodzero-front-sdk-alfa 0.0.2 → 0.0.5

package/README.md

@@ -7,7 +7,6 @@ A lightweight OOP library for frontend applications to easily interact with Kodz
 ```bash
 npm install kodzero-front-sdk-alfa
 ```
-```
 
 ## Authentication
 
@@ -54,8 +53,6 @@ Creating and using models is the core functionality of the SDK. Models provide a
 ### Creating a Model
 
 ```javascript
-import Schema from 'validno';
-
 // Define your data model interface
 interface User {
   _id?: string;
@@ -64,13 +61,13 @@ interface User {
   createdAt?: Date;
 }
 
-// Optional: Create a schema for validation
-const userSchema = new Schema({
+// Optional: Create a schema object for validation
+const userSchema = {
   _id: { type: String },
   name: { type: String },
   email: { type: String },
   createdAt: { type: Date }
-});
+};
 
 // Create a model for the 'users' collection
 const User = kodzero.createModel<User>({
@@ -142,6 +139,14 @@ interface CarMethods {
   isVintage: () => boolean;
 }
 
+// Define your schema
+const carSchema = {
+  _id: { type: String },
+  make: { type: String },
+  model: { type: String },
+  year: { type: Number }
+};
+
 // Create the model with the custom methods type
 const Car = kodzero.createModel<Car, CarMethods>({
   collection: 'cars',
@@ -224,16 +229,16 @@ const deleteResults = await User.deleteMany(['id1', 'id2', 'id3']);
 
 ## Validation
 
-The SDK uses the `validno` library for schema-based validation. When creating a model with a schema, you can validate your data:
+The SDK has built-in validation capabilities based on `validno` package ([Validno docs](https://validno.kodzero.pro/)). When creating a model with a schema, you can validate your data:
 
 ```javascript
 // Define a schema with validation rules
-const carSchema = new Schema({
+const carSchema = {
   _id: { type: String },
   make: { type: String, required: true },
   model: { type: String, required: true },
-  year: { type: Number, min: 1900, max: 2100 }
-});
+  year: { type: Number }
+};
 
 const Car = kodzero.createModel<Car>({
   collection: 'cars',
@@ -269,8 +274,20 @@ interface Profile {
   }
 }
 
+const profileSchema = {
+  _id: { type: String },
+  user: {
+    name: { type: String },
+    contact: {
+        email: { type: String },
+        phone: { type: String }
+    }
+  }
+};
+
 const Profile = kodzero.createModel<Profile>({
-  collection: 'profiles'
+  collection: 'profiles',
+  schema: profileSchema
 });
 
 const profile = new Profile({

package/dist/Kodzero.d.ts

@@ -1,7 +1,7 @@
 import FluidFetch from "fluid-fetch";
-import { KodzeroAuth } from "./auth/index.js";
+import KodzeroAuth from "./auth/index.js";
 import { ModelOptions } from "./model/BaseModel.js";
-import { TokensManagerClass } from "./auth/tokens.js";
+import TokensManagerClass from "./auth/tokens.js";
 interface Options {
     host: string;
 }
@@ -19,6 +19,7 @@ declare class Kodzero {
         registerMethod<K extends keyof M>(name: K, fn: M[K]): void;
         find(id: string): Promise<T>;
         findMany(options?: import("./model/createModel.js").FindManyOptions | {}): Promise<T[]>;
+        findManyPaginated(options?: import("./model/createModel.js").FindManyOptions | {}, page?: number, perPage?: number): Promise<import("./model/PaginatedResult.js").default<T>>;
         create(data: T): Promise<T>;
         createMany(data: T[]): Promise<T[]>;
         update(id: string, data: Partial<T>): Promise<T>;

package/dist/Kodzero.js

@@ -1,12 +1,13 @@
 import FluidFetch from "fluid-fetch";
-import { KodzeroAuth } from "./auth/index.js";
+import KodzeroAuth from "./auth/index.js";
 import createModel from "./model/createModel.js";
-import { TokensManagerClass } from "./auth/tokens.js";
+import TokensManagerClass from "./auth/tokens.js";
 class Kodzero {
+    host;
+    auth;
+    tokensManager;
+    api;
     constructor(options) {
-        this.createModel = (options) => {
-            return createModel(Object.assign(Object.assign({}, options), { host: this.host }), this.api);
-        };
         this.tokensManager = new TokensManagerClass('', '');
         this.host = options.host;
         this.api = new FluidFetch();
@@ -18,5 +19,8 @@ class Kodzero {
             return req;
         });
     }
+    createModel = (options) => {
+        return createModel({ ...options, host: this.host }, this.api);
+    };
 }
 export default Kodzero;

package/dist/__mocks__/fluid-fetch.d.ts

@@ -0,0 +1 @@
+export default function FluidFetch(this: any, options?: {}): void;

package/dist/__mocks__/fluid-fetch.js

@@ -0,0 +1,23 @@
+export default function FluidFetch(options = {}) {
+    this.options = options;
+    const middlewares = {
+        request: {
+            use: jest.fn()
+        },
+        response: {
+            use: jest.fn()
+        }
+    };
+    const request = jest.fn().mockImplementation(() => Promise.resolve({
+        data: {},
+        headers: {},
+        status: 200
+    }));
+    this.middlewares = middlewares;
+    this.request = request;
+    this.api = {
+        middlewares,
+        request
+    };
+}
+FluidFetch.prototype.constructor = FluidFetch;

package/dist/__mocks__/validno.d.ts

@@ -0,0 +1,5 @@
+export default function Schema(): {
+    validate: () => {
+        ok: boolean;
+    };
+};

package/dist/__mocks__/validno.js

@@ -0,0 +1,9 @@
+export default function Schema() {
+    return {
+        validate: () => {
+            return {
+                ok: true
+            };
+        },
+    };
+}

package/dist/auth/base.d.ts

@@ -1,7 +1,7 @@
 import FluidFetch from "fluid-fetch";
 import { AuthOptions } from "./index.js";
-import { TokensManagerClass } from "./tokens.js";
-export declare class KodzeroAuthBase {
+import TokensManagerClass from "./tokens.js";
+declare class KodzeroAuthBase {
     host: string;
     api: typeof FluidFetch;
     tokensManager: TokensManagerClass;
@@ -13,3 +13,4 @@ export declare class KodzeroAuthBase {
     signout: (...args: any[]) => Promise<any> | void;
     verify: (...args: any[]) => Promise<any> | void;
 }
+export default KodzeroAuthBase;

package/dist/auth/base.js

@@ -1,12 +1,10 @@
 import BaseAuthSchema from "../schemas/baseAuth.js";
 import validateApiResponse from "../utils/validateApiResponse.js";
-export class KodzeroAuthBase {
+class KodzeroAuthBase {
+    host;
+    api;
+    tokensManager;
     constructor(options, api, tokensManager) {
-        this.signin = (...args) => { };
-        this.signup = (...args) => { };
-        this.refresh = (...args) => { };
-        this.signout = (...args) => { };
-        this.verify = (...args) => { };
         BaseAuthSchema.validateOrThrow(options);
         this.host = options.host;
         this.api = api;
@@ -15,4 +13,10 @@ export class KodzeroAuthBase {
     _handleApiError(response) {
         return validateApiResponse(response);
     }
+    signin = (...args) => { };
+    signup = (...args) => { };
+    refresh = (...args) => { };
+    signout = (...args) => { };
+    verify = (...args) => { };
 }
+export default KodzeroAuthBase;

package/dist/auth/email.d.ts

@@ -1,7 +1,7 @@
 import FluidFetch from "fluid-fetch";
 import { AuthOptions } from "./index.js";
-import { KodzeroAuthBase } from "./base.js";
-import { TokensManagerClass } from "./tokens.js";
+import KodzeroAuthBase from "./base.js";
+import TokensManagerClass from "./tokens.js";
 interface KodzeroAuthEmailSignin {
     email: string;
     password: string;

package/dist/auth/email.js

@@ -1,70 +1,72 @@
-import { KodzeroAuthBase } from "./base.js";
-import buildURL from "../utils/buildURL_rename.js";
+import buildURL from "../utils/buildURL.js";
+import KodzeroAuthBase from "./base.js";
 class KodzeroAuthEmail extends KodzeroAuthBase {
+    tokensManager;
+    collection;
     constructor(options, api, tokensManager) {
         super(options, api, tokensManager);
-        this._setTokens = (access, refresh) => {
-            this.tokensManager.setAccess(access);
-            if (refresh)
-                this.tokensManager.setRefresh(refresh);
-        };
-        this.signin = async (input) => {
-            const url = buildURL(this.host, this.collection + '/signin');
-            const response = await this.api.post(url, input)
-                .headers({ 'Content-Type': 'application/json' });
-            await this._handleApiError(response);
-            const json = await response.json();
-            if (json.ok && json.tokens && json.tokens.access && json.tokens.refresh) {
-                this._setTokens(json.tokens.access, json.tokens.refresh);
-            }
-            return json.tokens;
-        };
-        this.signup = async (userData) => {
-            const url = buildURL(this.host, this.collection + '/signup');
-            const response = await this.api.post(url, userData)
-                .headers({ 'Content-Type': 'application/json' });
-            await this._handleApiError(response);
-            const json = await response.json();
-            if (json.ok && json.result && json.result.tokens.access && json.result.tokens.refresh) {
-                this._setTokens(json.result.tokens.access, json.result.tokens.refresh);
-            }
-            return json.result.user;
-        };
-        this.verify = async () => {
-            try {
-                const url = buildURL(this.host, this.collection + '/verify');
-                const response = await this.api.get(url);
-                const json = await response.json();
-                return json.ok ? true : false;
-            }
-            catch (error) {
-                console.warn("Token verification error:", error);
-                return false;
-            }
-        };
-        this.refresh = async () => {
-            const url = buildURL(this.host, this.collection + '/refresh');
-            const response = await this.api.post(url, { refresh: this.tokensManager.refresh })
-                .headers({ 'Content-Type': 'application/json' });
-            await this._handleApiError(response);
-            const json = await response.json();
-            if (json.ok && json.tokens && json.tokens.access) {
-                this.tokensManager.setAccess(json.tokens.access);
-            }
-            return json.ok ? true : false;
-        };
-        this.signout = async () => {
-            const url = buildURL(this.host, this.collection + '/signout');
-            const response = await this.api.post(url, {})
-                .headers({ 'Content-Type': 'application/json' });
-            await this._handleApiError(response);
-            const json = await response.json();
-            if (json.ok)
-                this.tokensManager.clear();
-            return json.ok ? true : false;
-        };
         this.tokensManager = tokensManager;
         this.collection = "auth/password";
     }
+    _setTokens = (access, refresh) => {
+        this.tokensManager.setAccess(access);
+        if (refresh)
+            this.tokensManager.setRefresh(refresh);
+    };
+    signin = async (input) => {
+        const url = buildURL(this.host, this.collection + '/signin');
+        const response = await this.api.post(url, input)
+            .headers({ 'Content-Type': 'application/json' });
+        await this._handleApiError(response);
+        const json = await response.json();
+        if (json.ok && json.tokens && json.tokens.access && json.tokens.refresh) {
+            this._setTokens(json.tokens.access, json.tokens.refresh);
+        }
+        return json.tokens;
+    };
+    signup = async (userData) => {
+        const url = buildURL(this.host, this.collection + '/signup');
+        const response = await this.api.post(url, userData)
+            .headers({ 'Content-Type': 'application/json' });
+        await this._handleApiError(response);
+        const json = await response.json();
+        if (json.ok && json.result && json.result.tokens.access && json.result.tokens.refresh) {
+            this._setTokens(json.result.tokens.access, json.result.tokens.refresh);
+        }
+        return json.result.user;
+    };
+    verify = async () => {
+        try {
+            const url = buildURL(this.host, this.collection + '/verify');
+            const response = await this.api.get(url);
+            const json = await response.json();
+            return json.ok ? true : false;
+        }
+        catch (error) {
+            console.warn("Token verification error:", error);
+            return false;
+        }
+    };
+    refresh = async () => {
+        const url = buildURL(this.host, this.collection + '/refresh');
+        const response = await this.api.post(url, { refresh: this.tokensManager.refresh })
+            .headers({ 'Content-Type': 'application/json' });
+        await this._handleApiError(response);
+        const json = await response.json();
+        if (json.ok && json.tokens && json.tokens.access) {
+            this.tokensManager.setAccess(json.tokens.access);
+        }
+        return json.ok ? true : false;
+    };
+    signout = async () => {
+        const url = buildURL(this.host, this.collection + '/signout');
+        const response = await this.api.post(url, {})
+            .headers({ 'Content-Type': 'application/json' });
+        await this._handleApiError(response);
+        const json = await response.json();
+        if (json.ok)
+            this.tokensManager.clear();
+        return json.ok ? true : false;
+    };
 }
 export default KodzeroAuthEmail;

package/dist/auth/index.d.ts

@@ -1,13 +1,14 @@
 import FluidFetch from "fluid-fetch";
-import { KodzeroAuthBase } from "./base.js";
+import KodzeroAuthBase from "./base.js";
 import KodzeroAuthEmail from "./email.js";
-import { TokensManagerClass } from "./tokens.js";
+import TokensManagerClass from "./tokens.js";
 export interface AuthOptions {
     host: string;
 }
-export declare class KodzeroAuth extends KodzeroAuthBase {
+declare class KodzeroAuth extends KodzeroAuthBase {
     email: KodzeroAuthEmail;
     setTokens: (access: string, refresh?: string) => void;
     clearTokens: () => void;
     constructor(options: AuthOptions, api: typeof FluidFetch, tokensManager: TokensManagerClass);
 }
+export default KodzeroAuth;

package/dist/auth/index.js

@@ -1,6 +1,9 @@
-import { KodzeroAuthBase } from "./base.js";
+import KodzeroAuthBase from "./base.js";
 import KodzeroAuthEmail from "./email.js";
-export class KodzeroAuth extends KodzeroAuthBase {
+class KodzeroAuth extends KodzeroAuthBase {
+    email;
+    setTokens;
+    clearTokens;
     constructor(options, api, tokensManager) {
         super(options, api, tokensManager);
         this.email = new KodzeroAuthEmail(options, api, tokensManager);
@@ -19,3 +22,4 @@ export class KodzeroAuth extends KodzeroAuthBase {
         };
     }
 }
+export default KodzeroAuth;

package/dist/auth/tokens.d.ts

@@ -1,4 +1,4 @@
-export declare class TokensManagerClass {
+declare class TokensManagerClass {
     access: string;
     refresh: string;
     constructor(access?: string, refresh?: string);
@@ -8,3 +8,4 @@ export declare class TokensManagerClass {
     setRefresh(token: string): void;
     clear(): void;
 }
+export default TokensManagerClass;

package/dist/auth/tokens.js

@@ -1,4 +1,6 @@
-export class TokensManagerClass {
+class TokensManagerClass {
+    access;
+    refresh;
     constructor(access = '', refresh = '') {
         this.access = access;
         this.refresh = refresh;
@@ -20,3 +22,4 @@ export class TokensManagerClass {
         this.refresh = '';
     }
 }
+export default TokensManagerClass;

package/dist/errors/KodzeroApiError.js

@@ -1,4 +1,7 @@
 class KodzeroApiError extends Error {
+    url;
+    statusCode;
+    details;
     constructor(url, statusCode, message, details) {
         super(message);
         this.name = "KodzeroApiError";

package/dist/errors/KodzeroValidationError.js

@@ -1,4 +1,5 @@
 class KodzeroValidationError extends Error {
+    errors;
     constructor(message, errors = []) {
         super(message);
         this.name = "KodzeroValidationError";

package/dist/index.d.ts

@@ -1 +1,2 @@
-export {};
+import Kodzero from "./Kodzero.js";
+export default Kodzero;

package/dist/index.js

@@ -1,49 +1,2 @@
-import Schema from "validno";
 import Kodzero from "./Kodzero.js";
-console.log('front-sdk started');
-const kodzero = new Kodzero({
-    host: 'http://localhost:6969'
-});
-const carSchema = new Schema({
-    _id: { type: String },
-    mark: { type: String },
-    model: { type: String },
-    year: { type: Number }
-});
-const Car = kodzero.createModel({
-    collection: 'cars',
-    schema: carSchema
-});
-Car.registerMethod('greet', function () {
-    return `Hello, I am a ${this.modelData.mark} ${this.modelData.model} from ${this.modelData.year}`;
-});
-const carRecord = await Car.get('68aec23b4732a44b3f559250');
-const data = carRecord.data();
-console.log(carRecord.greet());
-const signRes = await kodzero.auth.email.signin({ email: 'leshatour@gmail.com', password: 'qwerty123' });
-const verifyRes = await kodzero.auth.email.verify();
-console.log('verify1', verifyRes);
-const refreshRes = await kodzero.auth.email.refresh();
-console.log('refresh', refreshRes);
-const logoutRes = await kodzero.auth.email.signout();
-console.log('logout', logoutRes);
-const verifyRes2 = await kodzero.auth.email.verify();
-console.log('verify2', verifyRes2);
-const signupRes = await kodzero.auth.email.signup({
-    "name": "leshatour2",
-    "email": `leshatour${Math.random()}@gmail.com`,
-    "password": "qwerty123"
-});
-console.log('signup', signupRes);
-const URec = kodzero.createModel({
-    collection: 'scope-user',
-    schema: new Schema({
-        text: '134'
-    })
-});
-console.log(1);
-const urec = new URec({ _id: '', text: 'User Scope Example' });
-console.log(2);
-await urec.save();
-console.log(3);
-console.log(urec.data()._id);
+export default Kodzero;

package/dist/model/BaseModel.d.ts

@@ -3,7 +3,7 @@ import FluidFetch from "fluid-fetch";
 export interface ModelOptions {
     host: string;
     collection: string;
-    schema?: typeof Schema;
+    schema?: Record<string, any>;
 }
 declare class BaseModel<T extends {
     _id?: string;
@@ -12,12 +12,12 @@ declare class BaseModel<T extends {
     collection: string;
     modelData: T;
     schema?: typeof Schema;
-    api: typeof FluidFetch;
+    apiClient: typeof FluidFetch;
     id: string | null;
     static url: string;
     static collection: string;
     static api: typeof FluidFetch;
-    constructor(options: ModelOptions, api: typeof FluidFetch);
+    constructor(options: ModelOptions, apiClient: typeof FluidFetch);
     _setId: (id: string | null) => void;
     _setModelData: (data: T) => void;
     _handleApiError(response: Response): Promise<void>;

package/dist/model/BaseModel.js

@@ -1,35 +1,33 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
+import Schema from "validno";
 import constants from "./constants.js";
-import validateApiResponse from "../utils/validateApiResponse.js";
+import buildURL from "../utils/buildURL.js";
 import BaseModelSchema from "../schemas/baseModel.js";
-import buildURL from "../utils/buildURL_rename.js";
+import validateApiResponse from "../utils/validateApiResponse.js";
 class BaseModel {
-    constructor(options, api) {
-        this.modelData = {};
-        this._setId = (id) => {
-            this.id = id;
-        };
-        this._setModelData = (data) => {
-            this.modelData = data;
-            this._setId((data === null || data === void 0 ? void 0 : data._id) || null);
-        };
+    host;
+    collection;
+    modelData = {};
+    schema;
+    apiClient;
+    id;
+    static url;
+    static collection;
+    static api;
+    constructor(options, apiClient) {
         BaseModelSchema.validateOrThrow(options);
         this.host = options.host;
         this.collection = options.collection;
-        this.schema = options.schema;
-        this.api = api;
+        this.schema = options.schema ? new Schema({ ...options.schema }) : null;
+        this.apiClient = apiClient;
         this.id = null;
     }
+    _setId = (id) => {
+        this.id = id;
+    };
+    _setModelData = (data) => {
+        this.modelData = data;
+        this._setId(data?._id || null);
+    };
     _handleApiError(response) {
         return validateApiResponse(response);
     }
@@ -38,7 +36,7 @@ class BaseModel {
     }
     _dataWithoutId() {
         if (typeof this.modelData === 'object' && this.modelData !== null && '_id' in this.modelData) {
-            const _a = this.modelData, { _id } = _a, dataWithoutId = __rest(_a, ["_id"]);
+            const { _id, ...dataWithoutId } = this.modelData;
             return dataWithoutId;
         }
         return this.modelData;
@@ -80,7 +78,7 @@ class BaseModel {
             throw new Error(constants.RequiresId);
         }
         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);
         const json = await response.json();
@@ -92,7 +90,7 @@ class BaseModel {
             throw new Error(constants.RequiresId);
         }
         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);
         this.modelData = {};
@@ -100,7 +98,7 @@ class BaseModel {
     }
     async create() {
         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();

package/dist/model/PaginatedResult.d.ts

@@ -0,0 +1,28 @@
+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;
+}
+declare class PaginatedResult<T = {}> {
+    state: PaginationState;
+    data: Array<T>;
+    options: FindManyOptions | {};
+    private findManyFunction;
+    constructor(input: PaginationResultInput<T>);
+    next(): Promise<PaginatedResult<T>>;
+    previous(): Promise<PaginatedResult<T>>;
+    page(pageNumber: number): Promise<this>;
+    hasNext(): boolean;
+    hasPrevious(): boolean;
+}
+export default PaginatedResult;