@laboratoria/sdk-js 1.0.0 → 1.4.0

package/lib/core.js

@@ -1,12 +1,12 @@
 import md5 from 'blueimp-md5';
-import currencies from './currencies';
-import roles from './roles';
 import { createModels, extendSchemaDefinitions } from './model';
 import schema from '../schemas/core.json';
 
 const extended = {
   Country: {
+    primaryKey: 'code',
     plural: 'countries',
+    searchProps: ['code', 'name'],
   },
   User: {
     primaryKey: 'uid',
@@ -122,39 +122,33 @@ const extended = {
   Contract: {
     inputProps: [
       'user',
-      'countryCode',
-      'currency',
+      'country',
       'isEmployment',
-      'feeBasis',
       'feeAmount',
       'hoursPerWeek',
       'start',
       'end',
+      'isTrial',
+      'checkPilot',
+      'source',
     ],
-    properties: {
-      countryCode: {
-        enum: ['BR', 'CL', 'CO', 'MX', 'PE'],
-      },
-      currency: {
-        enum: currencies,
-      },
-    },
+    searchProps: [
+      'user.firstName',
+      'user.lastName',
+      'user.email',
+    ],
+    getOptionLabel: ({ id, user }) => `${user?.firstName} (id: ${id})`,
   },
   Gig: {
     inputProps: [
-      // 'contract',
       'cohort',
       'user',
+      'contract',
       'role',
       'hoursPerWeek',
       'start',
       'end',
     ],
-    properties: {
-      role: {
-        enum: roles,
-      },
-    },
   },
 };
 
@@ -162,8 +156,3 @@ export const createAPI = (url, state) => createModels(url, state, {
   ...schema,
   definitions: extendSchemaDefinitions(schema, extended),
 });
-
-// const {
-//   delete: _,
-//   ...userAPI,
-// } = createModel(coreApiUrl, state, 'users', schemas.user);

package/lib/model.js

@@ -1,6 +1,38 @@
 import { createClient } from './client.js';
 
 
+const isRequiredOneToOneRelation = (schema, key) => (
+  !!schema.properties
+  && !!schema.properties[key]
+  && !!schema.properties[key].$ref
+);
+
+const isOptionalOneToOneRelation = (schema, key) => (
+  !!schema.properties
+  && !!schema.properties[key]
+  && Array.isArray(schema.properties[key].anyOf)
+  && !!schema.properties[key].anyOf[0]?.$ref
+  && schema.properties[key].anyOf[1]?.type === 'null'
+);
+
+// const isOneToOneRelation = (schema, key) => (
+//   isRequiredOneToOneRelation(schema, key)
+//   || isOptionalOneToOneRelation(schema, key)
+// );
+
+const isOneToManyRelation = (schema, key) => (
+  schema.properties
+  && schema.properties[key]
+  && schema.properties[key].type === 'array'
+  && !!schema.properties[key].items.$ref
+);
+
+// const isRelation = (schema, key) => (
+//   isOneToOneRelation(schema, key)
+//   || isOneToManyRelation(schema, key)
+// );
+
+
 const createValidator = (schema) => {
   const properties = schema.properties || {};
   const inputProps = schema.inputProps || Object.keys(properties);
@@ -73,20 +105,12 @@ const createBuildURL = collectionName => (id, q) => {
 
 const serializeData = (data, schema) => {
   const hasInputProps = Array.isArray(schema.inputProps);
-  const payload = Object.keys(data).reduce(
+  return Object.keys(data).reduce(
     (memo, key) => {
       if (hasInputProps && !schema.inputProps.includes(key)) {
         return memo;
       }
-      const prop = (schema.properties || {})[key];
-      const isOptionalRelation = (
-        prop
-        && Array.isArray(prop.anyOf)
-        && prop.anyOf[0].$ref
-        && prop.anyOf[1]
-        && prop.anyOf[1].type === 'null'
-      );
-      if (isOptionalRelation && data[key] === null) {
+      if (isOptionalOneToOneRelation(schema, key) && data[key] === null) {
         return memo;
       }
       return {
@@ -96,36 +120,61 @@ const serializeData = (data, schema) => {
     },
     {},
   );
-
-  // {
-  //   signupCohort: {
-  //     connect: { id: signupCohort.id },
-  //   },
-  // }
-
-  return payload;
 };
 
 
-export const createModel = (baseUrl, state, collectionName, schema = {}) => {
+export const createModel = (baseUrl, state, collectionName, schema = {}, models = {}) => {
   const primaryKey = schema.primaryKey || 'id';
   const validator = createValidator(schema);
   const buildURL = createBuildURL(collectionName);
   const req = (...args) => createClient(baseUrl, state.authUser)(...args);
-  const create = q => req(buildURL(), {
+  const create = ({ data, ...q }) => req(buildURL(null, q), {
     method: 'POST',
-    body: Object.assign(q, { data: serializeData(q.data, schema) }),
-  });
-
-  const put = q => req(buildURL(q.where[primaryKey]), {
-    method: 'PUT',
-    body: Object.assign(q, { data: serializeData(q.data, schema) }),
+    body: serializeData(data, schema),
   });
+  const put = ({ data, ...q }) => {
+    const { where, ...rest } = q;
+    return req(buildURL(where[primaryKey], rest), {
+      method: 'PUT',
+      body: serializeData(data, schema),
+    });
+  };
 
   const parse = data => {
+    if (!data) {
+      return data;
+    }
+
     const parsed = Object.keys(data).reduce(
       (memo, key) => {
-        const { type, format } = schema.properties[key] || {};
+        const propSchema = schema.properties[key] || {};
+        const { type, format, items } = propSchema;
+        if (items && isOneToManyRelation(schema, key)) {
+          const relationModelName = items.$ref.split('/').pop().toLowerCase();
+          return {
+            ...memo,
+            [key]: (
+              typeof models[relationModelName]?.parse === 'function'
+                ? data[key].map(obj => models[relationModelName].parse(obj))
+                : data[key]
+            ),
+          };
+        }
+        const ref = (
+          isRequiredOneToOneRelation(schema, key)
+            ? propSchema.$ref
+            : isOptionalOneToOneRelation(schema, key)
+              ? propSchema.anyOf[0]?.$ref
+              : null
+        );
+
+        if (ref) {
+          const relationModelName = ref.split('/').pop().toLowerCase();
+          return {
+            ...memo,
+            [key]: models[relationModelName].parse(data[key]),
+          };
+        }
         return {
           ...memo,
           [key]: (
@@ -144,16 +193,50 @@ export const createModel = (baseUrl, state, collectionName, schema = {}) => {
     );
   };
 
+  const relations = Object.keys(schema.properties || {}).reduce(
+    (memo, key) => (
+      isRequiredOneToOneRelation(schema, key)
+        ? Object.assign(memo, {
+          all: memo.all.concat(key),
+          oneToOne: memo.oneToOne.concat(key),
+          requiredOneToOne: memo.requiredOneToOne.concat(key),
+        })
+        : isOptionalOneToOneRelation(schema, key)
+          ? Object.assign(memo, {
+            all: memo.all.concat(key),
+            oneToOne: memo.oneToOne.concat(key),
+            optionalOneToOne: memo.optionalOneToOne.concat(key),
+          })
+          : isOneToManyRelation(schema, key)
+            ? Object.assign(memo, {
+              all: memo.all.concat(key),
+              oneToMany: memo.oneToMany.concat(key),
+            })
+            : memo
+    ),
+    {
+      all: [],
+      oneToOne: [],
+      requiredOneToOne: [],
+      optionalOneToOne: [],
+      oneToMany: [],
+    },
+  );
+
   return {
     get schema() {
-      return schema;
+      return { ...schema, primaryKey };
     },
+    get relations() {
+      return relations;
+    },
+    parse,
     validateAttr: validator.validateAttr,
     validate: validator.validate,
     findMany: q => req(buildURL(null, q))
       .then(results => results.map(parse)),
     findById: (id, q) => req(buildURL(id, q))
-      .then(raw => !!raw ? parse(raw) : raw),
+      .then(parse),
     create,
     update: put,
     upsert: opts => (
@@ -162,27 +245,30 @@ export const createModel = (baseUrl, state, collectionName, schema = {}) => {
         : put({ where: opts.where, data: opts.update })
     ),
     delete: id => req(buildURL(id), { method: 'DELETE' }),
+    stats: () => req(buildURL('_stats')),
   };
 };
 
+
 export const createModels = (url, state, schema) => {
   return Object.keys(schema.properties).reduce(
     (prev, key) => {
       const name = schema.properties[key].$ref.split('/').pop();
-      return {
-        ...prev,
+      return Object.assign(prev, {
         [key]: createModel(
           url,
           state,
           schema.definitions[name].plural || `${key}s`,
           schema.definitions[name],
+          prev,
         ),
-      };
+      });
     },
     {},
   );
 };
 
+
 export const extendSchemaDefinitions = (schema, extended) => {
   return Object.keys(schema.definitions).reduce(
     (memo, key) => ({
@@ -208,4 +294,4 @@ export const extendSchemaDefinitions = (schema, extended) => {
     }),
     {},
   );
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "scripts": {
     "test": "jest --verbose --coverage",
@@ -9,25 +9,25 @@
   "license": "MIT",
   "dependencies": {
     "blueimp-md5": "^2.19.0",
-    "firebase": "^9.6.4"
+    "firebase": "^9.6.6"
   },
   "devDependencies": {
-    "@babel/core": "^7.16.12",
+    "@babel/core": "^7.17.4",
     "@babel/plugin-transform-modules-commonjs": "^7.16.8",
-    "babel-jest": "^27.4.6",
-    "jest": "^27.4.7",
-    "webpack": "^5.67.0",
+    "babel-jest": "^27.5.1",
+    "jest": "^27.5.1",
+    "webpack": "^5.69.0",
     "webpack-cli": "^4.9.2"
   },
   "jest": {
     "testEnvironment": "jsdom",
     "coverageThreshold": {
       "global": {
-        "statements": 96,
-        "branches": 91,
+        "statements": 96.9,
+        "branches": 94,
         "functions": 98,
-        "lines": 96
+        "lines": 96.7
       }
     }
   }
-}
+}

package/schemas/core.json

@@ -123,6 +123,12 @@
             "$ref": "#/definitions/Contract"
           }
         },
+        "contractsAsCheckPilot": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Contract"
+          }
+        },
         "gigs": {
           "type": "array",
           "items": {
@@ -485,30 +491,40 @@
         "isEmployment": {
           "type": "boolean"
         },
-        "currency": {
-          "type": "string",
-          "enum": [
-            "BRL",
-            "CLP",
-            "COP",
-            "MXN",
-            "PEN",
-            "USD"
-          ]
+        "feeAmount": {
+          "type": "integer"
         },
-        "feeBasis": {
-          "type": "string",
+        "isTrial": {
+          "type": "boolean",
+          "default": false
+        },
+        "source": {
+          "type": [
+            "string",
+            "null"
+          ],
           "enum": [
-            "HOURLY",
-            "MONTHLY"
+            "graduate",
+            "referral",
+            "jazzhr",
+            "web",
+            "linkedin",
+            "other"
           ]
         },
-        "feeAmount": {
-          "type": "integer"
-        },
         "user": {
           "$ref": "#/definitions/User"
         },
+        "checkPilot": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/User"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "country": {
           "$ref": "#/definitions/Country"
         },

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [14.x, 16.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test

package/index.spec.js

@@ -1,112 +0,0 @@
-import { initializeApp } from 'firebase/app';
-import {
-  getAuth,
-  onAuthStateChanged,
-  signInWithEmailAndPassword,
-  signOut,
-} from 'firebase/auth';
-import { createAPI as createCoreAPI } from './lib/core';
-import { createApp } from './index.js';
-
-jest.mock('./lib/core.js', () => ({
-  createAPI: jest.fn().mockReturnValue({
-    user: {
-      findById: jest.fn().mockResolvedValue({}),
-    },
-  }),
-}));
-
-beforeEach(() => {
-  initializeApp.mockClear();
-  onAuthStateChanged.mockClear();
-  signInWithEmailAndPassword.mockClear();
-});
-
-describe('createApp', () => {
-  it('should invoke firebase\'s initializaApp', () => {
-    createApp();
-    expect(initializeApp).toHaveBeenCalledTimes(1);
-    expect(initializeApp.mock.calls[0]).toMatchSnapshot();
-  });
-});
-
-describe('app.auth.onChange', () => {
-  it('should listen to firebase\'s onAuthStateChanged and notify subscribers when not authenticated', (done) => {
-    const { auth } = createApp();
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb();
-      return () => { };
-    });
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toBeNull();
-      expect(user).toBeNull();
-      done();
-    });
-  });
-
-  it('should fetch user from db when authenticated using coreAPI', (done) => {
-    const { auth } = createApp();
-    const mockAuthUser = { uid: 'xxx', getIdToken: () => 'token' };
-    const userMock = { uid: 'xxx', email: 'foo@bar.baz' };
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb(mockAuthUser);
-      return () => { };
-    });
-
-    createCoreAPI().user.findById.mockResolvedValue(userMock);
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toEqual(mockAuthUser);
-      expect(user).toEqual(userMock);
-      done();
-    });
-  });
-
-  it('should log error and reset state (authUser = null, user = null) when fetch user from db fails', (done) => {
-    const { auth } = createApp();
-    const mockAuthUser = { uid: 'xxx', getIdToken: () => 'token' };
-    const spy = jest.spyOn(console, 'error').mockImplementationOnce(() => { })
-    const error = new Error('OMG');
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb(mockAuthUser);
-      return () => { };
-    });
-
-    createCoreAPI().user.findById.mockRejectedValueOnce(error);
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toBeNull();
-      expect(user).toBeNull();
-      expect(spy).toHaveBeenCalledWith(error);
-      spy.mockRestore();
-      done();
-    });
-  });
-});
-
-describe('app.auth.signIn', () => {
-  it('should delegate to firebase\'s signInWithEmailAndPassword', async () => {
-    const { auth } = createApp();
-    const email = 'foo@bar.baz';
-    const pass = 'secret';
-
-    await auth.signIn(email, pass);
-
-    expect(signInWithEmailAndPassword).toHaveBeenCalledTimes(1);
-    expect(signInWithEmailAndPassword).toHaveBeenCalledWith({}, email, pass);
-  });
-});
-
-describe('app.auth.signOut', () => {
-  it('should delegate to firebase\'s signOut', async () => {
-    const { auth } = createApp();
-
-    await auth.signOut();
-
-    expect(signOut).toHaveBeenCalledTimes(1);
-  });
-});

package/lib/client.spec.js

@@ -1,77 +0,0 @@
-import { createClient } from './client.js';
-
-describe('client', () => {
-
-  beforeAll(() => window.fetch = jest.fn());
-
-  afterEach(() => {
-    window.fetch.mockClear();
-    jest.restoreAllMocks();
-  });
-
-  it('should delegate to global fetch and add mode:cors and parse JSON resp when OK', async () => {
-    window.fetch.mockResolvedValue({
-      json: jest.fn().mockResolvedValue({ ok: true }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const client = createClient(baseUrl);
-    expect(await client('/')).toEqual({ ok: true });
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {},
-    });
-  });
-
-  it('should reject when response.status > 202', async () => {
-    window.fetch.mockResolvedValue({
-      status: 400,
-      json: jest.fn().mockResolvedValue({ ok: false }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const client = createClient(baseUrl);
-    await expect(client('/')).rejects.toThrow('HTTP Error 400');
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {},
-    });
-  });
-
-  it('should add token when authUser present', async () => {
-    window.fetch.mockResolvedValue({
-      json: jest.fn().mockResolvedValue({ ok: true }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const user = { getIdToken: jest.fn().mockReturnValueOnce('xxx') };
-    const client = createClient(baseUrl, user);
-    expect(await client('/')).toEqual({ ok: true });
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {
-        authorization: 'Bearer xxx',
-      },
-    });
-    expect(user.getIdToken).toHaveBeenCalledTimes(1);
-  });
-
-  it('should add content-type header and stringify body when necessary', async () => {
-    window.fetch.mockResolvedValue({
-      json: jest.fn().mockResolvedValue({ ok: true }),
-    });
-    const baseUrl = 'http://foo.bar';
-    const client = createClient(baseUrl);
-    const body = { foo: 'bar' };
-    expect(await client('/', { method: 'POST', body })).toEqual({ ok: true });
-    expect(window.fetch).toHaveBeenCalledTimes(1);
-    expect(window.fetch).toHaveBeenCalledWith(`${baseUrl}/`, {
-      mode: 'cors',
-      headers: {
-        'content-type': 'application/json',
-      },
-      method: 'POST',
-      body: JSON.stringify(body),
-    });
-  });
-});

package/lib/currencies.js

@@ -1,3 +0,0 @@
-const currencies = ['BRL', 'CLP', 'COP', 'MXN', 'PEN', 'USD'];
-
-export default currencies;

package/lib/curriculum.spec.js

@@ -1,194 +0,0 @@
-import { createAPI } from './curriculum';
-
-describe('projects', () => {
-  describe('findMany', () => {
-    // TODO: errores HTTP, GitHub caido, repo borrado, etc...
-
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().projects.findMany()
-        .then((projects) => {
-          expect(projects).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/projects.json',
-          );
-        });
-    });
-
-    it('gets projects in specific tag when passed as option', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().projects.findMany({ tag: 'v3.0.0' })
-        .then((projects) => {
-          expect(projects).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(1);
-          expect(global.fetch).toHaveBeenCalledWith(
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v3.0.0/dist/projects.json',
-          );
-        });
-    });
-
-    it('gets projects in specific tag when passed as option', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : [
-              { locale: 'es-ES', track: 'ux' },
-              { locale: 'es-ES', track: 'js' },
-              { locale: 'pt-BR', track: 'ux' },
-            ]
-        ),
-      }));
-
-      return createAPI().projects.findMany({
-        tag: 'v3.0.0',
-        locale: 'es-ES',
-        track: 'ux',
-      })
-        .then((projects) => {
-          expect(projects).toEqual([{ locale: 'es-ES', track: 'ux' }]);
-          expect(global.fetch).toHaveBeenCalledTimes(1);
-          expect(global.fetch).toHaveBeenCalledWith(
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v3.0.0/dist/projects.json',
-          );
-        });
-    });
-
-    // it should filter by tag, locale and track...
-  });
-
-  describe('findById', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : {}
-        ),
-      }));
-
-      return createAPI().projects.findById('cipher')
-        .then((project) => {
-          expect(project).toEqual({});
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/projects/cipher.json',
-          );
-        });
-    });
-  });
-});
-
-describe('topics', () => {
-  describe('findMany', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().topics.findMany()
-        .then((topics) => {
-          expect(topics).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/topics.json',
-          );
-        });
-    });
-  });
-
-  describe('findById', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : {}
-        ),
-      }));
-
-      return createAPI().topics.findById('javascript')
-        .then((topic) => {
-          expect(topic).toEqual({});
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/topics/javascript.json',
-          );
-        });
-    });
-  });
-});
-
-describe('learningObjectives', () => {
-  describe('findMany', () => {
-    it('sends request to get latest version and then corresponding json', () => {
-      global.fetch = jest.fn().mockImplementation(async url => ({
-        status: 200,
-        json: jest.fn().mockResolvedValue(
-          url.startsWith('https://api.')
-            ? { tag_name: 'v4.0.0' }
-            : []
-        ),
-      }));
-
-      return createAPI().learningObjectives.findMany()
-        .then((learningObjectives) => {
-          expect(learningObjectives).toEqual([]);
-          expect(global.fetch).toHaveBeenCalledTimes(2);
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            1,
-            'https://api.github.com/repos/Laboratoria/bootcamp/releases/latest',
-          );
-          expect(global.fetch).toHaveBeenNthCalledWith(
-            2,
-            'https://raw.githubusercontent.com/Laboratoria/bootcamp/v4.0.0/dist/learning-objectives.json',
-          );
-        });
-    });
-  });
-});

package/lib/model.spec.js

@@ -1,242 +0,0 @@
-import { createModel } from './model.js';
-import { createClient } from './client.js';
-
-jest.mock('./client.js');
-
-beforeEach(() => createClient().mockClear());
-
-describe('model.schema', () => {
-  it('should be empty object by default', () => {
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(model.schema).toEqual({});
-  });
-
-  it('should get the model\'s schema', () => {
-    const schema = {
-      properties: {
-        a: { type: 'string' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.schema).toEqual(schema);
-  });
-});
-
-describe('model.findMany(options)', () => {
-  it('should send GET request', async () => {
-    const schema = {
-      properties: {
-        id: { type: 'integer' },
-        createdAt: { type: 'string', format: 'date-time' },
-      },
-    };
-    const now = new Date();
-    const client = createClient().mockResolvedValue([{
-      id: 1,
-      createdAt: now.toISOString(),
-    }]);
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    const results = await model.findMany();
-    expect(results).toEqual([{ id: 1, createdAt: now }]);
-    expect(results[0].createdAt instanceof Date).toBe(true);
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo');
-  });
-});
-
-describe('model.findById(id, options)', () => {
-  it('should send GET request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.findById(1)).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1');
-  });
-});
-
-describe('model.create(options)', () => {
-  it('should send POST request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.create({ data: { ok: true } })).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo', {
-      body: { data: { ok: true } },
-      method: 'POST',
-    });
-  });
-});
-
-describe('model.update(options)', () => {
-  it('should send POST request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.update({ where: { id: 1 }, data: { ok: true } })).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      body: { where: { id: 1 }, data: { ok: true } },
-      method: 'PUT',
-    });
-  });
-
-  it('should exclude null values for optional relation props', async () => {
-    const client = createClient().mockResolvedValue({});
-    const schema = {
-      properties: {
-        signupCohort: {
-          anyOf: [
-            { '$ref': '#/definitions/Cohort' },
-            { type: 'null' },
-          ],
-        },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(await model.update({
-      where: { id: 1 },
-      data: { signupCohort: null },
-    })).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      body: {
-        where: { id: 1 },
-        data: {},
-      },
-      method: 'PUT',
-    });
-  });
-});
-
-describe('model.upsert(options)', () => {
-  it('should send POST request when new row', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    const result = await model.upsert({
-      where: {},
-      create: { ok: true },
-    });
-    expect(result).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo', {
-      body: { data: { ok: true } },
-      method: 'POST',
-    });
-  });
-
-  it('should send PUT request when existing row', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    const result = await model.upsert({
-      where: { id: 1 },
-      update: { ok: true },
-    });
-    expect(result).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      body: {
-        where: { id: 1 },
-        data: { ok: true },
-      },
-      method: 'PUT',
-    });
-  });
-});
-
-describe('model.delete(id)', () => {
-  it('should send POST request', async () => {
-    const client = createClient().mockResolvedValue({});
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(await model.delete(1)).toEqual({});
-    expect(client).toHaveBeenCalledTimes(1);
-    expect(client).toHaveBeenCalledWith('/foo/1', {
-      method: 'DELETE',
-    });
-  });
-});
-
-describe('model.validateAttr(key, value)', () => {
-  it('should not validate when no schema', () => {
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(model.validateAttr('a', 1)).toBeUndefined();
-  });
-
-  it('should validate text when required', () => {
-    const schema = {
-      properties: {
-        a: { type: 'string' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', '')).toBe('Field is required');
-  });
-
-  it('should validate number when required', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer', required: true },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('Invalid number format');
-  });
-
-  it('should validate enum', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer', enum: [1, 2, 3] },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('foo is not one of: 1,2,3');
-  });
-
-  it('should allow empty enum when not required', () => {
-    const schema = {
-      properties: {
-        a: { type: ['integer', 'null'], enum: [1, 2, 3] },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', null)).toBeUndefined();
-    expect(model.validateAttr('a', undefined)).toBeUndefined();
-    expect(model.validateAttr('a', '')).toBeUndefined();
-  });
-});
-
-describe('model.validate(attributes)', () => {
-  it('should not validate when no schema', () => {
-    const model = createModel('http://1.2.3.4', {}, 'foo');
-    expect(model.validate({ a: 1 })).toEqual({});
-  });
-
-  it('should validate when schema present', () => {
-    const schema = {
-      properties: {
-        a: { type: 'string' },
-        b: { type: 'integer' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validate({ a: '', b: 1 })).toEqual({ a: 'Field is required' });
-  });
-
-  it('should validate number when required', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer' },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('Invalid number format');
-  });
-
-  it('should validate enum', () => {
-    const schema = {
-      properties: {
-        a: { type: 'integer', enum: [1, 2, 3] },
-      },
-    };
-    const model = createModel('http://1.2.3.4', {}, 'foo', schema);
-    expect(model.validateAttr('a', 'foo')).toBe('foo is not one of: 1,2,3');
-  });
-});