kodzero-front-sdk-alfa 0.0.2

package/dist/fetcher/InterceptorManager.js

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,77 @@
+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;

package/dist/fetcher/index.js

@@ -0,0 +1,194 @@
+import MiddlewareManager from './MiddlewareManager.js';
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+class FluidFetch {
+    constructor() {
+        this.cache = new Map();
+        this.pendingRequests = new Map();
+        const requestManager = new MiddlewareManager();
+        const responseManager = new MiddlewareManager();
+        this.middlewares = {
+            request: requestManager,
+            response: responseManager
+        };
+        this.interceptors = {
+            request: requestManager,
+            response: responseManager
+        };
+        Object.defineProperty(this.interceptors.request, 'push', {
+            value: (fn) => requestManager.use(fn)
+        });
+        Object.defineProperty(this.interceptors.response, 'push', {
+            value: (fn) => responseManager.use(fn)
+        });
+    }
+    get(url, config = {}) {
+        return this._createRequest('GET', url, null, config);
+    }
+    post(url, data = null, config = {}) {
+        return this._createRequest('POST', url, data, config);
+    }
+    put(url, data = null, config = {}) {
+        return this._createRequest('PUT', url, data, config);
+    }
+    delete(url, config = {}) {
+        return this._createRequest('DELETE', url, null, config);
+    }
+    _createRequest(method, url, data = null, config = {}) {
+        const request = {
+            method,
+            url,
+            data,
+            headers: Object.assign({}, (config.headers || {})),
+            params: Object.assign({}, (config.params || {})),
+            cache: config.cache,
+            timeout: config.timeout,
+            abortController: new AbortController()
+        };
+        return new FluidFetchRequest(this, request);
+    }
+    _getCacheKey(request) {
+        return `${request.method}:${request.url}:${JSON.stringify(request.params)}`;
+    }
+    _buildUrl(url, params) {
+        if (!params || Object.keys(params).length === 0)
+            return url;
+        const query = Object.entries(params)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+            .join('&');
+        return `${url}?${query}`;
+    }
+    getCachedResponse(cacheKey) {
+        const entry = this.cache.get(cacheKey);
+        if (entry && entry.expires > Date.now()) {
+            return entry.response;
+        }
+        if (entry) {
+            this.cache.delete(cacheKey);
+        }
+        return undefined;
+    }
+    getPendingRequest(cacheKey) {
+        return this.pendingRequests.get(cacheKey);
+    }
+    registerPendingRequest(cacheKey, controller) {
+        this.pendingRequests.set(cacheKey, controller);
+    }
+    removePendingRequest(cacheKey) {
+        this.pendingRequests.delete(cacheKey);
+    }
+    cacheResponse(cacheKey, response, ttl) {
+        const duration = typeof ttl === 'number' ? ttl : 3600000;
+        const entry = {
+            response: response,
+            expires: Date.now() + duration
+        };
+        this.cache.set(cacheKey, entry);
+    }
+    clearRequestMiddlewares() {
+        this.middlewares.request.clear();
+    }
+    clearResponseMiddlewares() {
+        this.middlewares.response.clear();
+    }
+    clearRequestInterceptors() {
+        this.clearRequestMiddlewares();
+    }
+    clearResponseInterceptors() {
+        this.clearResponseMiddlewares();
+    }
+}
+class FluidFetchRequest {
+    constructor(fluidFetch, request) {
+        this.fluidFetch = fluidFetch;
+        this.request = request;
+        this.promise = null;
+    }
+    headers(headers) {
+        Object.assign(this.request.headers, headers);
+        return this;
+    }
+    params(params) {
+        Object.assign(this.request.params, params);
+        return this;
+    }
+    body(data) {
+        this.request.data = data;
+        return this;
+    }
+    cache(ttl) {
+        this.request.cache = typeof ttl === 'boolean' ?
+            3600000 :
+            ttl;
+        return this;
+    }
+    timeout(ms) {
+        this.request.timeout = ms;
+        return this;
+    }
+    cancel() {
+        this.request.abortController.abort();
+        return this;
+    }
+    then(onFulfilled, onRejected) {
+        if (!this.promise) {
+            this.promise = this._executeRequest();
+        }
+        return this.promise.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        if (!this.promise) {
+            this.promise = this._executeRequest();
+        }
+        return this.promise.catch(onRejected);
+    }
+    async _executeRequest() {
+        let request = this.request;
+        request = await this.fluidFetch.middlewares.request.runMiddlewares(request);
+        const cacheKey = this.fluidFetch._getCacheKey(request);
+        if (request.cache) {
+            const cachedResponse = this.fluidFetch.getCachedResponse(cacheKey);
+            if (cachedResponse) {
+                return cachedResponse.clone();
+            }
+        }
+        const pendingController = this.fluidFetch.getPendingRequest(cacheKey);
+        if (pendingController) {
+            pendingController.abort();
+        }
+        this.fluidFetch.registerPendingRequest(cacheKey, request.abortController);
+        let timeoutId;
+        if (request.timeout && request.timeout > 0) {
+            timeoutId = setTimeout(() => {
+                const timeoutError = new TimeoutError(`Request timed out after ${request.timeout}ms`);
+                request.abortController.abort(timeoutError);
+            }, request.timeout);
+        }
+        try {
+            const response = await fetch(this.fluidFetch._buildUrl(request.url, request.params), {
+                method: request.method,
+                headers: request.headers,
+                body: request.data ? JSON.stringify(request.data) : undefined,
+                signal: request.abortController.signal
+            });
+            let processedResponse = response;
+            processedResponse = await this.fluidFetch.middlewares.response.runMiddlewares(processedResponse);
+            if (request.cache) {
+                this.fluidFetch.cacheResponse(cacheKey, processedResponse.clone(), typeof request.cache === 'boolean' ? undefined : request.cache);
+            }
+            return processedResponse;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            this.fluidFetch.removePendingRequest(cacheKey);
+        }
+    }
+}
+export { TimeoutError, MiddlewareManager };
+export default FluidFetch;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,49 @@
+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);

package/dist/model/BaseModel.d.ts

@@ -0,0 +1,38 @@
+import Schema from "validno";
+import FluidFetch from "fluid-fetch";
+export interface ModelOptions {
+    host: string;
+    collection: string;
+    schema?: typeof Schema;
+}
+declare class BaseModel<T extends {
+    _id?: string;
+}> {
+    host: string;
+    collection: string;
+    modelData: 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);
+    _setId: (id: string | null) => void;
+    _setModelData: (data: T) => void;
+    _handleApiError(response: Response): Promise<void>;
+    data(): T;
+    _dataWithoutId(): Omit<T, "_id"> | {};
+    _setNested(key: string, value: any): T;
+    set(data: Record<string, any> | string, value?: any): T;
+    validate(): {
+        ok: boolean;
+        errors: string[];
+        joinErrors: () => string;
+    };
+    update(): Promise<T>;
+    delete(): Promise<boolean>;
+    create(): Promise<T>;
+    save(): Promise<T>;
+}
+export default BaseModel;

package/dist/model/BaseModel.js

@@ -0,0 +1,119 @@
+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 constants from "./constants.js";
+import validateApiResponse from "../utils/validateApiResponse.js";
+import BaseModelSchema from "../schemas/baseModel.js";
+import buildURL from "../utils/buildURL_rename.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);
+        };
+        BaseModelSchema.validateOrThrow(options);
+        this.host = options.host;
+        this.collection = options.collection;
+        this.schema = options.schema;
+        this.api = api;
+        this.id = null;
+    }
+    _handleApiError(response) {
+        return validateApiResponse(response);
+    }
+    data() {
+        return this.modelData;
+    }
+    _dataWithoutId() {
+        if (typeof this.modelData === 'object' && this.modelData !== null && '_id' in this.modelData) {
+            const _a = this.modelData, { _id } = _a, dataWithoutId = __rest(_a, ["_id"]);
+            return dataWithoutId;
+        }
+        return this.modelData;
+    }
+    _setNested(key, value) {
+        const keys = key.split('.');
+        let obj = this.modelData;
+        while (keys.length > 1) {
+            const k = keys.shift();
+            if (!(k in obj))
+                obj[k] = {};
+            obj = obj[k];
+        }
+        obj[keys[0]] = value;
+        return this.modelData;
+    }
+    set(data, value) {
+        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;
+    }
+    validate() {
+        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;
+    }
+    async update() {
+        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;
+    }
+    async delete() {
+        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 = {};
+        return true;
+    }
+    async create() {
+        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;
+    }
+    async save() {
+        if (this.id) {
+            return this.update();
+        }
+        else {
+            return this.create();
+        }
+    }
+}
+export default BaseModel;

package/dist/model/baseModelOptionsSchema.d.ts

@@ -0,0 +1,2 @@
+declare const baseModelOptionsSchema: any;
+export default baseModelOptionsSchema;

package/dist/model/baseModelOptionsSchema.js

@@ -0,0 +1,10 @@
+import Schema from 'validno';
+const baseModelOptionsSchema = new Schema({
+    url: {
+        type: String
+    },
+    collection: {
+        type: String
+    }
+});
+export default baseModelOptionsSchema;

package/dist/model/configSchema.js

@@ -0,0 +1 @@
+"use strict";

package/dist/model/constants.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    NoSchema: string;
+    RequiresId: string;
+    DataTypeNotArray: string;
+    RequiresIdsArray: string;
+    DistinctRequiresFieldsArray: string;
+};
+export default _default;

package/dist/model/constants.js

@@ -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/dist/model/createModel.d.ts

@@ -0,0 +1,28 @@
+import FluidFetch from 'fluid-fetch';
+import BaseModel, { ModelOptions } from './BaseModel.js';
+export interface FindManyOptions {
+    page: number;
+    perPage: number;
+    search?: string;
+    sort?: string;
+    fields?: string[];
+}
+declare const createModel: <T extends {
+    _id?: string;
+}, M = {}>(options: ModelOptions, api: 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[]>;
+    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;
+};
+export default createModel;