kodzero-front-sdk-alfa 0.0.4 → 0.0.6

package/dist/model/createModel.js

@@ -1,159 +1,157 @@
-var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
-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 BaseModel from './BaseModel.js';
 import validateApiResponse from '../utils/validateApiResponse.js';
 import buildURL from '../utils/buildURL.js';
 import constants from './constants.js';
-const createModel = (options, api) => {
-    var _a;
-    const Model = (_a = class extends BaseModel {
-            static async _handleApiError(response) {
-                return validateApiResponse(response);
-            }
-            static async get(id) {
-                if (!id)
-                    throw new Error(constants.RequiresId);
-                const getUrl = buildURL(Model.host, Model.collection, id);
-                const response = await Model.api.get(getUrl);
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return new Model(json.result);
-            }
-            static registerMethod(name, fn) {
-                Model.prototype[name] = fn;
-            }
-            static async find(id) {
-                if (!id)
-                    throw new Error(constants.RequiresId);
-                const getUrl = buildURL(Model.host, Model.collection, id);
-                const response = await Model.api.get(getUrl);
-                await Model._handleApiError(response);
-                const data = await response.json();
-                return data.result;
-            }
-            static async findMany(options) {
-                const getUrl = buildURL(Model.host, Model.collection);
-                const params = Object.assign({}, options);
-                const response = await Model.api.get(getUrl).params(params);
-                await Model._handleApiError(response);
-                const data = await response.json();
-                return data.result.found;
-            }
-            static async create(data) {
-                const createUrl = buildURL(Model.host, Model.collection);
-                const _b = data, { _id } = _b, dataWithoutId = __rest(_b, ["_id"]);
-                const response = await Model.api.post(createUrl)
-                    .body(dataWithoutId)
-                    .headers({
-                    'Content-Type': 'application/json'
-                });
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
-            }
-            static async createMany(records) {
-                if (!records || !Array.isArray(records) || !records.length) {
-                    throw new Error(constants.DataTypeNotArray);
-                }
-                const createUrl = buildURL(Model.host, Model.collection) + '/batch';
-                const dataWithoutId = records.map(item => {
-                    const _b = item, { _id } = _b, rest = __rest(_b, ["_id"]);
-                    return rest;
-                });
-                const response = await Model.api.post(createUrl)
-                    .body(dataWithoutId)
-                    .headers({
-                    'Content-Type': 'application/json'
-                });
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
-            }
-            static async update(id, data) {
-                if (!id) {
-                    throw new Error(constants.RequiresId);
-                }
-                const updateUrl = buildURL(Model.host, Model.collection, id);
-                const _b = data, { _id } = _b, dataWithoutId = __rest(_b, ["_id"]);
-                const response = await Model.api.patch(updateUrl)
-                    .body(dataWithoutId)
-                    .headers({ 'Content-Type': 'application/json' });
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
-            }
-            static async updateMany(updates) {
-                if (!updates || !Array.isArray(updates) || updates.length === 0) {
-                    throw new Error(constants.DataTypeNotArray);
-                }
-                if (updates.some(update => !update._id)) {
-                    throw new Error("All updates must have an _id");
-                }
-                const updateUrl = buildURL(Model.host, Model.collection) + '/batch';
-                const response = await Model.api.patch(updateUrl)
-                    .body(updates)
-                    .headers({ 'Content-Type': 'application/json' });
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
+import PaginatedResult from './PaginatedResult.js';
+const createModel = (options, apiClient) => {
+    const Model = class extends BaseModel {
+        static host = options.host;
+        static collection = options.collection;
+        static apiClient = apiClient;
+        static async _handleApiError(response) {
+            return validateApiResponse(response);
+        }
+        static async get(id) {
+            if (!id)
+                throw new Error(constants.RequiresId);
+            const getUrl = buildURL(Model.host, Model.collection, id);
+            const response = await Model.api.get(getUrl);
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return new Model(json.result);
+        }
+        static registerMethod(name, fn) {
+            Model.prototype[name] = fn;
+        }
+        static async find(id) {
+            if (!id)
+                throw new Error(constants.RequiresId);
+            const getUrl = buildURL(Model.host, Model.collection, id);
+            const response = await Model.apiClient.get(getUrl);
+            await Model._handleApiError(response);
+            const data = await response.json();
+            return data.result;
+        }
+        static async findMany(options) {
+            const getUrl = buildURL(Model.host, Model.collection);
+            const params = { ...options };
+            const response = await Model.apiClient.get(getUrl).params(params);
+            await Model._handleApiError(response);
+            const data = await response.json();
+            return data.result.found;
+        }
+        static async findManyPaginated(options = {}, page = 1, perPage = 25) {
+            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 };
+            const response = await Model.apiClient.get(getUrl).params(params);
+            await Model._handleApiError(response);
+            const data = await response.json();
+            return new PaginatedResult({
+                data: data.result.found,
+                state: data.result,
+                options,
+                findManyFunction: Model.findManyPaginated
+            });
+        }
+        static async create(data) {
+            const createUrl = buildURL(Model.host, Model.collection);
+            const { _id, ...dataWithoutId } = data;
+            const response = await Model.apiClient.post(createUrl)
+                .body(dataWithoutId)
+                .headers({
+                'Content-Type': 'application/json'
+            });
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        static async createMany(records) {
+            if (!records || !Array.isArray(records) || !records.length) {
+                throw new Error(constants.DataTypeNotArray);
             }
-            static async delete(id) {
-                if (!id)
-                    throw new Error(constants.RequiresId);
-                const deleteUrl = buildURL(Model.host, Model.collection, id);
-                const response = await Model.api.delete(deleteUrl);
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
+            const createUrl = buildURL(Model.host, Model.collection) + '/batch';
+            const dataWithoutId = records.map(item => {
+                const { _id, ...rest } = item;
+                return rest;
+            });
+            const response = await Model.apiClient.post(createUrl)
+                .body(dataWithoutId)
+                .headers({
+                'Content-Type': 'application/json'
+            });
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        static async update(id, data) {
+            if (!id) {
+                throw new Error(constants.RequiresId);
             }
-            static async deleteMany(ids) {
-                if (!ids || ids.length === 0) {
-                    throw new Error(constants.RequiresIdsArray);
-                }
-                const deleteUrl = buildURL(Model.host, Model.collection) + '/batch';
-                const response = await Model.api.delete(deleteUrl)
-                    .body({ ids })
-                    .headers({ 'Content-Type': 'application/json' });
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
+            const updateUrl = buildURL(Model.host, Model.collection, id);
+            const { _id, ...dataWithoutId } = data;
+            const response = await Model.apiClient.patch(updateUrl)
+                .body(dataWithoutId)
+                .headers({ 'Content-Type': 'application/json' });
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        static async updateMany(updates) {
+            if (!updates || !Array.isArray(updates) || updates.length === 0) {
+                throw new Error(constants.DataTypeNotArray);
             }
-            static async distinct(fields, filter) {
-                if (!fields || fields.length === 0) {
-                    throw new Error(constants.DistinctRequiresFieldsArray);
-                }
-                const distinctUrl = buildURL(Model.host, Model.collection, 'distinct');
-                const response = await Model.api.post(distinctUrl)
-                    .params({ fields: fields.join(','), filter: filter ? JSON.stringify(filter) : undefined })
-                    .headers({ 'Content-Type': 'application/json' });
-                await Model._handleApiError(response);
-                const json = await response.json();
-                return json.result;
+            if (updates.some(update => !update._id)) {
+                throw new Error("All updates must have an _id");
             }
-            constructor(data) {
-                super(options, api);
-                this.modelData = Object.assign(Object.assign({}, data), { _id: null });
-                this.id = null;
+            const updateUrl = buildURL(Model.host, Model.collection) + '/batch';
+            const response = await Model.apiClient.patch(updateUrl)
+                .body(updates)
+                .headers({ 'Content-Type': 'application/json' });
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        static async delete(id) {
+            if (!id)
+                throw new Error(constants.RequiresId);
+            const deleteUrl = buildURL(Model.host, Model.collection, id);
+            const response = await Model.apiClient.delete(deleteUrl);
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        static async deleteMany(ids) {
+            if (!ids || ids.length === 0)
+                throw new Error(constants.RequiresIdsArray);
+            const deleteUrl = buildURL(Model.host, Model.collection) + '/batch';
+            const response = await Model.apiClient.delete(deleteUrl)
+                .body({ ids })
+                .headers({ 'Content-Type': 'application/json' });
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        static async distinct(fields, filter) {
+            throw new Error('Distinct method is disabled in this SDK version');
+            if (!fields || fields.length === 0) {
+                throw new Error(constants.DistinctRequiresFieldsArray);
             }
-        },
-        __setFunctionName(_a, "Model"),
-        _a.host = options.host,
-        _a.collection = options.collection,
-        _a.api = api,
-        _a);
+            const distinctUrl = buildURL(Model.host, Model.collection, 'distinct');
+            const response = await Model.apiClient.get(distinctUrl)
+                .params({ fields: fields.join(','), filter: filter ? JSON.stringify(filter) : undefined })
+                .headers({ 'Content-Type': 'application/json' });
+            await Model._handleApiError(response);
+            const json = await response.json();
+            return json.result;
+        }
+        constructor(data) {
+            super(options, apiClient);
+            this.modelData = { ...data, _id: null };
+            this.id = null;
+        }
+    };
     return Model;
 };
 export default createModel;

package/dist/schemas/baseAuth.js

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

package/dist/schemas/baseModel.js

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

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/kodzero.ts","../src/dev.ts","../src/auth/base.ts","../src/auth/email.ts","../src/auth/index.ts","../src/auth/tokens.ts","../src/errors/kodzeroapierror.ts","../src/errors/kodzerovalidationerror.ts","../src/model/basemodel.ts","../src/model/constants.ts","../src/model/createmodel.ts","../src/model/index.ts","../src/schemas/baseauth.ts","../src/schemas/basemodel.ts","../src/types/module.d.ts","../src/types/responses.ts","../src/utils/buildurl.ts","../src/utils/validateapiresponse.ts"],"version":"5.8.3"}
+{"root":["../src/kodzero.ts","../src/dev.ts","../src/index.ts","../src/__mocks__/fluid-fetch.ts","../src/__mocks__/validno.ts","../src/auth/base.ts","../src/auth/email.ts","../src/auth/index.ts","../src/auth/tokens.ts","../src/errors/kodzeroapierror.ts","../src/errors/kodzerovalidationerror.ts","../src/model/basemodel.ts","../src/model/paginatedresult.ts","../src/model/constants.ts","../src/model/createmodel.ts","../src/model/index.ts","../src/schemas/baseauth.ts","../src/schemas/basemodel.ts","../src/types/module.d.ts","../src/types/responses.ts","../src/utils/buildurl.ts","../src/utils/validateapiresponse.ts"],"version":"5.8.3"}

package/dist/utils/buildURL.js

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

package/dist/utils/validateApiResponse.js

@@ -9,6 +9,6 @@ const validateApiResponse = async (response) => {
     catch (err) {
         json = null;
     }
-    throw new KodzeroApiError(response.url, response.status, `API Request failed with status ${response.status}. Details: ${(json === null || json === void 0 ? void 0 : json.details) || (json === null || json === void 0 ? void 0 : json.error) || response.statusText}`, (json === null || json === void 0 ? void 0 : json.details) || (json === null || json === void 0 ? void 0 : json.error) || response.statusText);
+    throw new KodzeroApiError(response.url, response.status, `API Request failed with status ${response.status}. Details: ${json?.details || json?.error || response.statusText}`, json?.details || json?.error || response.statusText);
 };
 export default validateApiResponse;

package/jest.config.ts

@@ -64,25 +64,22 @@ const config: Config = {
   // maxWorkers: "50%",
 
   // An array of directory names to be searched recursively up from the requiring module's location
-  // moduleDirectories: [
-  //   "node_modules"
-  // ],
+  moduleDirectories: ['node_modules'],
+
+  extensionsToTreatAsEsm: [".ts"],
 
   // An array of file extensions your modules use
-  // moduleFileExtensions: [
-  //   "js",
-  //   "mjs",
-  //   "cjs",
-  //   "jsx",
-  //   "ts",
-  //   "tsx",
-  //   "json",
-  //   "node"
-  // ],
+  moduleFileExtensions: [
+    "js",
+    "ts",
+    "json",
+    "node"
+  ],
 
   // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
-  // moduleNameMapper: {},
-
+  moduleNameMapper: {
+    "^(\\.{1,2}/.*)\\.js$": "$1",
+  },
   // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
   // modulePathIgnorePatterns: [],
 
@@ -93,7 +90,7 @@ const config: Config = {
   // notifyMode: "failure-change",
 
   // A preset that is used as a base for Jest's configuration
-  // preset: undefined,
+  preset: 'ts-jest',
 
   // Run tests from one or more projects
   // projects: undefined,
@@ -137,14 +134,14 @@ const config: Config = {
   // snapshotSerializers: [],
 
   // The test environment that will be used for testing
-  // testEnvironment: "jest-environment-node",
+  testEnvironment: "node",
 
   // Options that will be passed to the testEnvironment
   // testEnvironmentOptions: {},
 
   // Adds a location field to test results
   // testLocationInResults: false,
-
+  testMatch: ['**/?(*.)+(spec|test).[jt]s?(x)'],
   // The glob patterns Jest uses to detect test files
   // testMatch: [
   //   "**/__tests__/**/*.[jt]s?(x)",
@@ -166,7 +163,14 @@ const config: Config = {
   // testRunner: "jest-circus/runner",
 
   // A map from regular expressions to paths to transformers
-  // transform: undefined,
+  transform: {
+    "^.+\\.ts?$": [
+      "ts-jest",
+      {
+        useESM: true,
+      },
+    ],
+  },
 
   // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
   // transformIgnorePatterns: [

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "kodzero-front-sdk-alfa",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc -b src/",
     "tsc-watch": "tsc --b --watch src/",
     "tscw": "tsc --b --watch src/",
     "dev": "nodemon dist/dev.js",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test": "npx jest",
     "prepare": "npm version patch && npm run tsc"
   },
   "type": "module",
@@ -19,11 +19,12 @@
     "validno": "^0.3.5"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.27.1",
     "@types/express": "^5.0.1",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/node": "^22.14.0",
     "eslint": "^9.24.0",
-    "jest": "^29.7.0"
+    "jest": "^30.1.3",
+    "ts-jest": "^29.4.3"
   }
 }

package/src/__mocks__/fluid-fetch.ts

@@ -0,0 +1,35 @@
+// Mock for fluid-fetch as a constructor with options
+export default function FluidFetch(this: any, options = {}) {
+  // Store options
+  this.options = options;
+  
+  // Define middlewares
+  const middlewares = {
+    request: {
+      use: jest.fn()
+    },
+    response: {
+      use: jest.fn()
+    }
+  };
+  
+  // Define request method
+  const request = jest.fn().mockImplementation(() => Promise.resolve({
+    data: {},
+    headers: {},
+    status: 200
+  }));
+  
+  // Assign properties to this.api
+  this.middlewares = middlewares;
+  this.request = request;
+  
+  // Create api property for compatibility
+  this.api = {
+    middlewares,
+    request
+  };
+}
+
+// Make it constructable without 'new'
+FluidFetch.prototype.constructor = FluidFetch;

package/src/__mocks__/validno.ts

@@ -0,0 +1,12 @@
+// Simple mock for fluid-fetch
+export default function Schema() {
+  return {
+    // Mock the methods and properties you're using
+    validate: () => {
+        return {
+            ok: true
+        }
+    },
+    // Add other methods as needed
+  };
+}

package/src/__tests__/Kodzero.test.ts

@@ -0,0 +1,9 @@
+import Kodzero from '../Kodzero.js';
+
+it('should create an instance if host provided', async () => {
+    const kodzero = new Kodzero({
+        host: 'http://localhost:6969'
+    });
+
+    expect(kodzero).toBeInstanceOf(Kodzero);
+});

package/src/__tests__/utils/buildURL.test.ts

@@ -0,0 +1,18 @@
+import buildURL from '../../utils/buildURL.js';
+
+describe('buildURL', () => {
+    test('buildURL constructs a URL without an ID', () => {
+        const url = buildURL('https://example.com', 'collection');
+        expect(url).toBe('https://example.com/collection');
+    });
+
+    test('buildURL constructs a URL with an ID', () => {
+        const url = buildURL('https://example.com', 'collection', '123');
+        expect(url).toBe('https://example.com/collection/123');
+    });
+
+    test('buildURL handles trailing slashes in baseUrl and collection', () => {
+        const url = buildURL('https://example.com/', '/collection/', '123');
+        expect(url).toBe('https://example.com/collection/123');
+    });
+})

package/src/auth/base.ts

@@ -29,10 +29,10 @@ class KodzeroAuthBase {
      * Base auth methods.
      * These will be overridden by specific strategies (e.g. email, social, etc.)
      */
-    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 => {}
 }