kodzero-front-sdk-alfa 0.0.4 → 0.0.6

package/README.md

@@ -18,14 +18,14 @@ const kodzero = new Kodzero({
   host: 'https://api.your-backend.com'
 });
 
-// Sign up a new user
-const signupResult = await kodzero.auth.signup({
+// New user registration
+const registerResult = await kodzero.auth.register({
   email: 'user@example.com',
   password: 'secure_password'
 });
 
-// Sign in
-const signinResult = await kodzero.auth.signin({
+// Login
+const loginResult = await kodzero.auth.login({
   email: 'user@example.com',
   password: 'secure_password'
 });
@@ -36,8 +36,8 @@ const verified = await kodzero.auth.verify();
 // Refresh the token
 const refreshed = await kodzero.auth.refresh();
 
-// Sign out
-await kodzero.auth.signout();
+// Logout
+await kodzero.auth.logout();
 
 // Manually set tokens (useful for persisting sessions)
 kodzero.auth.setTokens('access_token', 'refresh_token');

package/dist/Kodzero.d.ts

@@ -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

@@ -3,10 +3,11 @@ import KodzeroAuth from "./auth/index.js";
 import createModel from "./model/createModel.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

@@ -7,10 +7,10 @@ declare class KodzeroAuthBase {
     tokensManager: TokensManagerClass;
     constructor(options: AuthOptions, api: typeof FluidFetch, tokensManager: TokensManagerClass);
     _handleApiError(response: Response): Promise<void>;
-    signin: (...args: any[]) => Promise<any> | void;
-    signup: (...args: any[]) => Promise<any> | void;
+    login: (...args: any[]) => Promise<any> | void;
+    register: (...args: any[]) => Promise<any> | void;
     refresh: (...args: any[]) => Promise<any> | void;
-    signout: (...args: any[]) => Promise<any> | void;
+    logout: (...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";
 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,5 +13,10 @@ class KodzeroAuthBase {
     _handleApiError(response) {
         return validateApiResponse(response);
     }
+    login = (...args) => { };
+    register = (...args) => { };
+    refresh = (...args) => { };
+    logout = (...args) => { };
+    verify = (...args) => { };
 }
 export default KodzeroAuthBase;

package/dist/auth/email.d.ts

@@ -2,7 +2,7 @@ import FluidFetch from "fluid-fetch";
 import { AuthOptions } from "./index.js";
 import KodzeroAuthBase from "./base.js";
 import TokensManagerClass from "./tokens.js";
-interface KodzeroAuthEmailSignin {
+interface KodzeroAuthEmailLogin {
     email: string;
     password: string;
 }
@@ -11,13 +11,13 @@ declare class KodzeroAuthEmail extends KodzeroAuthBase {
     collection: "auth/password";
     constructor(options: AuthOptions, api: typeof FluidFetch, tokensManager: TokensManagerClass);
     _setTokens: (access: string, refresh?: string) => void;
-    signin: (input: KodzeroAuthEmailSignin) => Promise<{
+    login: (input: KodzeroAuthEmailLogin) => Promise<{
         access: string;
         refresh: string;
     }>;
-    signup: (userData: Record<string, string>) => Promise<Record<string, any>>;
+    register: (userData: Record<string, string>) => Promise<Record<string, any>>;
     verify: () => Promise<any>;
     refresh: () => Promise<any>;
-    signout: () => Promise<any>;
+    logout: () => Promise<any>;
 }
 export default KodzeroAuthEmail;

package/dist/auth/email.js

@@ -1,70 +1,72 @@
 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);
+    };
+    login = async (input) => {
+        const url = buildURL(this.host, this.collection + '/login');
+        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;
+    };
+    register = async (userData) => {
+        const url = buildURL(this.host, this.collection + '/register');
+        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;
+    };
+    logout = async () => {
+        const url = buildURL(this.host, this.collection + '/logout');
+        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.js

@@ -1,12 +1,15 @@
 import KodzeroAuthBase from "./base.js";
 import KodzeroAuthEmail from "./email.js";
 class KodzeroAuth extends KodzeroAuthBase {
+    email;
+    setTokens;
+    clearTokens;
     constructor(options, api, tokensManager) {
         super(options, api, tokensManager);
         this.email = new KodzeroAuthEmail(options, api, tokensManager);
-        this.signin = this.email.signin;
-        this.signup = this.email.signup;
-        this.signout = this.email.signout;
+        this.login = this.email.login;
+        this.register = this.email.register;
+        this.logout = this.email.logout;
         this.verify = this.email.verify;
         this.refresh = this.email.refresh;
         this.setTokens = (access, refresh) => {

package/dist/auth/tokens.js

@@ -1,4 +1,6 @@
 class TokensManagerClass {
+    access;
+    refresh;
     constructor(access = '', refresh = '') {
         this.access = access;
         this.refresh = refresh;

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

@@ -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,36 +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 BaseModelSchema from "../schemas/baseModel.js";
 import buildURL from "../utils/buildURL.js";
+import BaseModelSchema from "../schemas/baseModel.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 ? new Schema(Object.assign({}, options.schema)) : null;
-        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);
     }
@@ -39,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;
@@ -81,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();
@@ -93,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 = {};
@@ -101,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;

package/dist/model/PaginatedResult.js

@@ -0,0 +1,49 @@
+class PaginatedResult {
+    state;
+    data;
+    options;
+    findManyFunction;
+    constructor(input) {
+        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() {
+        this.state.page++;
+        const result = await this.findManyFunction(this.options, this.state.page, this.state.limit);
+        this.data = result.data;
+        return this;
+    }
+    async previous() {
+        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) {
+        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() {
+        return this.state.page < this.state.totalPages;
+    }
+    hasPrevious() {
+        return this.state.page > 1;
+    }
+}
+export default PaginatedResult;

package/dist/model/createModel.d.ts

@@ -1,5 +1,6 @@
 import FluidFetch from 'fluid-fetch';
 import BaseModel, { ModelOptions } from './BaseModel.js';
+import PaginatedResult from './PaginatedResult.js';
 export interface FindManyOptions {
     page: number;
     perPage: number;
@@ -9,12 +10,13 @@ export interface FindManyOptions {
 }
 declare const createModel: <T extends {
     _id?: string;
-}, M = {}>(options: ModelOptions, api: typeof FluidFetch) => {
+}, M = {}>(options: ModelOptions, apiClient: typeof FluidFetch) => {
     new (data: T): BaseModel<T> & M;
     get(id: string): Promise<BaseModel<T> & M>;
     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>;