@laboratoria/sdk-js 0.2.0 → 1.3.0

package/README.md

@@ -1,5 +1,7 @@
 ## Laboratoria JavaScript (browser) SDK
 
+[![Node.js CI](https://github.com/Laboratoria/sdk-js/actions/workflows/node.js.yml/badge.svg)](https://github.com/Laboratoria/sdk-js/actions/workflows/node.js.yml)
+
 :warning: This tool is still in draft stage and is likely to change without
 notice.
 
@@ -25,7 +27,6 @@ const app = createApp({
   firebaseApiKey: '',
   firebaseProject: '',
   coreApiUrl: '',
-  teamApiUrl: '',
   jobsApiUrl: '',
 });
 ```
@@ -79,7 +80,6 @@ app.user.create({
 ### Cohorts
 
 ```js
-// Cohorts API
 app.cohort.findMany({
   where: {
     end: { gt: new Date() },
@@ -96,13 +96,50 @@ app.cohort.findMany({
 
 ### Students
 
+WIP
+
 ### Dropouts
 
+WIP
 
 ### Projects
 
 ```js
 app.project.findMany();
 
-// app.learningObjectives.
+app.project.findMany({ tag: 'v3.0.0' });
+
+app.project.findMany({
+  locale: 'es-ES',
+  track: 'js',
+});
+
+app.project.findById('cipher');
+
+app.project.findById('cipher', { tag: 'v3.0.0' });
 ```
+
+### Topics
+
+```js
+app.topic.findMany();
+
+app.topic.findMany({ tag: 'v3.0.0' });
+
+app.topic.findMany({
+  locale: 'es-ES',
+  track: 'js',
+});
+
+app.topic.findById('javascript');
+
+app.topic.findById('javascript', { tag: 'v3.0.0' });
+```
+
+### Learning Objectives
+
+```js
+app.learningObjective.findMany();
+
+app.learningObjective.findMany({ tag: 'v3.0.0' });
+```

package/index.js

@@ -6,14 +6,13 @@ import {
   signOut,
 } from 'firebase/auth';
 import { createAPI as createCoreAPI } from './lib/core';
+import { createAPI as createCurriculumAPI } from './lib/curriculum';
 import { createAPI as createJobsAPI } from './lib/jobs';
-import { createAPI as createTeamAPI } from './lib/team';
 
 export const createApp = ({
   firebaseApiKey = 'AIzaSyAXbaEbpq8NOfn0r8mIrcoHvoGRkJThwdc',
   firebaseProject = 'laboratoria-la',
   coreApiUrl = 'https://us-central1-outpost-272720.cloudfunctions.net/core-api',
-  teamApiUrl = 'https://us-central1-outpost-272720.cloudfunctions.net/team-api',
   jobsApiUrl = 'https://us-central1-outpost-272720.cloudfunctions.net/jobs-api',
 } = {}) => {
   const firebaseApp = initializeApp({
@@ -26,8 +25,8 @@ export const createApp = ({
   const firebaseAuth = getAuth(firebaseApp);
   const state = { authUser: undefined, user: undefined };
   const coreAPI = createCoreAPI(coreApiUrl, state);
-  const teamAPI = createTeamAPI(teamApiUrl, state);
   const jobsAPI = createJobsAPI(jobsApiUrl, state);
+  const curriculumAPI = createCurriculumAPI();
 
   const authAPI = {
     onChange: fn => onAuthStateChanged(firebaseAuth, (authUser) => {
@@ -56,9 +55,9 @@ export const createApp = ({
   };
 
   return {
-    auth: authAPI,
     ...jobsAPI,
-    ...teamAPI,
+    ...curriculumAPI,
     ...coreAPI,
+    auth: authAPI,
   };
 };

package/lib/core.js

@@ -3,6 +3,11 @@ import { createModels, extendSchemaDefinitions } from './model';
 import schema from '../schemas/core.json';
 
 const extended = {
+  Country: {
+    primaryKey: 'code',
+    plural: 'countries',
+    searchProps: ['code', 'name'],
+  },
   User: {
     primaryKey: 'uid',
     inputProps: [
@@ -69,6 +74,7 @@ const extended = {
     properties: {},
     parse: (props) => {
       const now = Date.now();
+      // TODO: Handle case where start and/or end have not been  selected in query
       const status = (
         props.start > now
           ? 'upcoming'
@@ -113,14 +119,33 @@ const extended = {
       'cohort.name',
     ],
   },
+  Contract: {
+    inputProps: [
+      'user',
+      'country',
+      'isEmployment',
+      'feeAmount',
+      'hoursPerWeek',
+      'start',
+      'end',
+    ],
+    searchProps: ['user.firstName'],
+    getOptionLabel: ({ id, user }) => `${user?.firstName} (id: ${id})`,
+  },
+  Gig: {
+    inputProps: [
+      'cohort',
+      'user',
+      'contract',
+      'role',
+      'hoursPerWeek',
+      'start',
+      'end',
+    ],
+  },
 };
 
 export const createAPI = (url, state) => createModels(url, state, {
   ...schema,
   definitions: extendSchemaDefinitions(schema, extended),
 });
-
-// const {
-//   delete: _,
-//   ...userAPI,
-// } = createModel(coreApiUrl, state, 'users', schemas.user);

package/lib/curriculum.js

@@ -0,0 +1,59 @@
+const releasesUrl = 'https://api.github.com/repos/Laboratoria/bootcamp/releases';
+const rawUrl = 'https://raw.githubusercontent.com/Laboratoria/bootcamp';
+
+const getLatestVersion = () => fetch(`${releasesUrl}/latest`)
+  .then(resp => resp.json())
+  .then(({ tag_name }) => tag_name);
+
+const fetchProjects = async tag => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/projects.json`)
+    .then(resp => resp.json())
+);
+
+const fetchProject = async (slug, tag) => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/projects/${slug}.json`)
+    .then(resp => resp.json())
+);
+
+const fetchTopics = async tag => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/topics.json`)
+    .then(resp => resp.json())
+);
+
+const fetchTopic = async (slug, tag) => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/topics/${slug}.json`)
+    .then(resp => resp.json())
+);
+
+const fetchLearningObjectives = async tag => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/learning-objectives.json`)
+    .then(resp => resp.json())
+);
+
+const filterByLocaleAndTrack = opts => arr => arr.filter((obj) => {
+  if (opts.locale && opts.locale !== obj.locale) {
+    return false;
+  }
+  if (opts.track && opts.track !== obj.track) {
+    return false;
+  }
+  return true;
+});
+
+export const createAPI = () => {
+  return {
+    projects: {
+      findMany: (opts = {}) => fetchProjects(opts.tag)
+        .then(filterByLocaleAndTrack(opts)),
+      findById: (slug, opts = {}) => fetchProject(slug, opts.tag),
+    },
+    topics: {
+      findMany: (opts = {}) => fetchTopics(opts.tag)
+        .then(filterByLocaleAndTrack(opts)),
+      findById: (slug, opts = {}) => fetchTopic(slug, opts.tag),
+    },
+    learningObjectives: {
+      findMany: (opts = {}) => fetchLearningObjectives(opts.tag),
+    },
+  };
+};

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);
@@ -71,44 +103,14 @@ const createBuildURL = collectionName => (id, q) => {
 };
 
 
-const createBuildQuery = defaultInclude => (q = {}) => ({
-  ...(!q.select && Object.keys(defaultInclude).length && { include: defaultInclude }),
-  ...q,
-});
-
-
-const buildDefaultInclude = schema => Object.keys(schema.properties || {}).reduce(
-  (memo, key) => (
-    (
-      schema.properties[key].$ref
-      || (
-        Array.isArray(schema.properties[key].anyOf)
-        && schema.properties[key].anyOf[0].$ref
-      )
-    )
-      ? { ...memo, [key]: true }
-      : memo
-  ),
-  {},
-);
-
-
 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 {
@@ -118,14 +120,6 @@ const serializeData = (data, schema) => {
     },
     {},
   );
-
-  // {
-  //   signupCohort: {
-  //     connect: { id: signupCohort.id },
-  //   },
-  // }
-
-  return payload;
 };
 
 
@@ -133,18 +127,18 @@ export const createModel = (baseUrl, state, collectionName, schema = {}) => {
   const primaryKey = schema.primaryKey || 'id';
   const validator = createValidator(schema);
   const buildURL = createBuildURL(collectionName);
-  const defaultInclude = buildDefaultInclude(schema);
-  const buildQuery = createBuildQuery(defaultInclude);
   const req = (...args) => createClient(baseUrl, state.authUser)(...args);
-  const create = q => req(buildURL(), {
+  const create = ({ data, ...q }) => req(buildURL(null, q), {
     method: 'POST',
-    body: buildQuery(Object.assign(q, { data: serializeData(q.data, schema) })),
-  });
-
-  const put = q => req(buildURL(q.where[primaryKey]), {
-    method: 'PUT',
-    body: buildQuery(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 => {
     const parsed = Object.keys(data).reduce(
@@ -168,18 +162,48 @@ 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 include() {
-      return defaultInclude;
+    get relations() {
+      return relations;
     },
     validateAttr: validator.validateAttr,
     validate: validator.validate,
-    findMany: q => req(buildURL(null, buildQuery(q)))
+    findMany: q => req(buildURL(null, q))
       .then(results => results.map(parse)),
-    findById: (id, q) => req(buildURL(id, buildQuery(q)))
+    findById: (id, q) => req(buildURL(id, q))
       .then(raw => !!raw ? parse(raw) : raw),
     create,
     update: put,

package/package.json

@@ -1,24 +1,33 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "0.2.0",
+  "version": "1.3.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "scripts": {
-    "test": "jest --verbose --coverage"
+    "test": "jest --verbose --coverage",
+    "changelog": "git log $(git describe --tags --abbrev=0)..HEAD --oneline --format=\"* %h %s (%an)\""
   },
   "license": "MIT",
   "dependencies": {
     "blueimp-md5": "^2.19.0",
-    "firebase": "^9.6.2"
+    "firebase": "^9.6.6"
   },
   "devDependencies": {
-    "@babel/core": "^7.16.7",
+    "@babel/core": "^7.17.2",
     "@babel/plugin-transform-modules-commonjs": "^7.16.8",
-    "babel-jest": "^27.4.6",
-    "jest": "^27.4.7",
-    "webpack": "^5.65.0",
-    "webpack-cli": "^4.9.1"
+    "babel-jest": "^27.5.1",
+    "jest": "^27.5.1",
+    "webpack": "^5.68.0",
+    "webpack-cli": "^4.9.2"
   },
   "jest": {
-    "testEnvironment": "jsdom"
+    "testEnvironment": "jsdom",
+    "coverageThreshold": {
+      "global": {
+        "statements": 97,
+        "branches": 92,
+        "functions": 98,
+        "lines": 97
+      }
+    }
   }
 }

package/schemas/core.json

@@ -1,6 +1,23 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
+    "Country": {
+      "type": "object",
+      "properties": {
+        "code": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "contracts": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Contract"
+          }
+        }
+      }
+    },
     "User": {
       "type": "object",
       "properties": {
@@ -99,6 +116,18 @@
               "type": "null"
             }
           ]
+        },
+        "contracts": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Contract"
+          }
+        },
+        "gigs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Gig"
+          }
         }
       }
     },
@@ -270,20 +299,26 @@
             "$ref": "#/definitions/Dropout"
           }
         },
+        "gigs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Gig"
+          }
+        },
         "links": {
           "type": "array",
           "items": {
             "$ref": "#/definitions/CohortLink"
           }
         },
-        "legacySlug": {
-          "type": "string"
-        },
         "signupUsers": {
           "type": "array",
           "items": {
             "$ref": "#/definitions/User"
           }
+        },
+        "legacySlug": {
+          "type": "string"
         }
       }
     },
@@ -307,7 +342,7 @@
             "null"
           ]
         },
-        "studentCode": {
+        "legacyStudentCode": {
           "type": [
             "string",
             "null"
@@ -415,10 +450,115 @@
           "$ref": "#/definitions/User"
         }
       }
+    },
+    "Contract": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "updatedAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "createdBy": {
+          "type": "string"
+        },
+        "start": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "end": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "format": "date-time"
+        },
+        "hoursPerWeek": {
+          "type": "integer"
+        },
+        "isEmployment": {
+          "type": "boolean"
+        },
+        "feeAmount": {
+          "type": "integer"
+        },
+        "user": {
+          "$ref": "#/definitions/User"
+        },
+        "country": {
+          "$ref": "#/definitions/Country"
+        },
+        "gigs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Gig"
+          }
+        }
+      }
+    },
+    "Gig": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "updatedAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "createdBy": {
+          "type": "string"
+        },
+        "start": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "end": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "format": "date-time"
+        },
+        "hoursPerWeek": {
+          "type": "integer"
+        },
+        "role": {
+          "type": "string",
+          "enum": [
+            "bm",
+            "pdc",
+            "js",
+            "ux"
+          ]
+        },
+        "user": {
+          "$ref": "#/definitions/User"
+        },
+        "contract": {
+          "$ref": "#/definitions/Contract"
+        },
+        "cohort": {
+          "$ref": "#/definitions/Cohort"
+        }
+      }
     }
   },
   "type": "object",
   "properties": {
+    "country": {
+      "$ref": "#/definitions/Country"
+    },
     "user": {
       "$ref": "#/definitions/User"
     },
@@ -442,6 +582,12 @@
     },
     "dropout": {
       "$ref": "#/definitions/Dropout"
+    },
+    "contract": {
+      "$ref": "#/definitions/Contract"
+    },
+    "gig": {
+      "$ref": "#/definitions/Gig"
     }
   }
 }

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 { createClient } from './lib/client.js';
-import { createApp } from './index.js';
-
-jest.mock('./lib/client.js');
-
-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 and add isStaff, isManager, etc', (done) => {
-    const { auth } = createApp();
-    const mockAuthUser = { uid: 'xxx', getIdToken: () => 'token' };
-    const userMock = { uid: 'xxx', email: 'foo@bar.baz' };
-
-    onAuthStateChanged.mockImplementationOnce((_, cb) => {
-      cb(mockAuthUser);
-      return () => { };
-    });
-
-    createClient().mockResolvedValueOnce(userMock);
-
-    auth.onChange(({ authUser, user }) => {
-      expect(authUser).toEqual(mockAuthUser);
-      expect(user).toEqual({
-        ...userMock,
-        isStaff: false,
-        isManager: false,
-        isFinance: false,
-        isAdmin: false,
-      });
-      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 () => { };
-    });
-
-    createClient().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/model.spec.js

@@ -1,243 +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: {},
-        include: { signupCohort: true },
-      },
-      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');
-  });
-});

package/lib/team.js

@@ -1,52 +0,0 @@
-import { createModels, extendSchemaDefinitions } from './model';
-import currencies from './currencies';
-import roles from './roles';
-import schema from '../schemas/team.json';
-
-const extended = {
-  Country: {
-    plural: 'countries',
-  },
-  Contract: {
-    inputProps: [
-      'uid',
-      'countryCode',
-      'currency',
-      'isEmployment',
-      'feeBasis',
-      'feeAmount',
-      'hoursPerWeek',
-      'start',
-      'end',
-    ],
-    properties: {
-      countryCode: {
-        enum: ['BR', 'CL', 'CO', 'MX', 'PE'],
-      },
-      currency: {
-        enum: currencies,
-      },
-    },
-  },
-  Gig: {
-    inputProps: [
-      // 'contract',
-      'cohortId',
-      'uid',
-      'role',
-      'hoursPerWeek',
-      'start',
-      'end',
-    ],
-    properties: {
-      role: {
-        enum: roles,
-      },
-    },
-  },
-};
-
-export const createAPI = (url, state) => createModels(url, state, {
-  ...schema,
-  definitions: extendSchemaDefinitions(schema, extended),
-});

package/schemas/team.json

@@ -1,146 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "definitions": {
-    "Country": {
-      "type": "object",
-      "properties": {
-        "code": {
-          "type": "string"
-        },
-        "name": {
-          "type": "string"
-        },
-        "contracts": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/Contract"
-          }
-        }
-      }
-    },
-    "Contract": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "type": "integer"
-        },
-        "createdAt": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "updatedAt": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "createdBy": {
-          "type": "string"
-        },
-        "uid": {
-          "type": "string"
-        },
-        "isEmployment": {
-          "type": "boolean"
-        },
-        "currency": {
-          "type": "string"
-        },
-        "feeBasis": {
-          "type": "string",
-          "enum": [
-            "HOURLY",
-            "MONTHLY"
-          ]
-        },
-        "feeAmount": {
-          "type": "integer"
-        },
-        "hoursPerWeek": {
-          "type": "integer"
-        },
-        "start": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "end": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "format": "date-time"
-        },
-        "country": {
-          "$ref": "#/definitions/Country"
-        },
-        "gigs": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/Gig"
-          }
-        }
-      }
-    },
-    "Gig": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "type": "integer"
-        },
-        "createdAt": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "updatedAt": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "createdBy": {
-          "type": "string"
-        },
-        "role": {
-          "type": "string",
-          "enum": [
-            "bm",
-            "pdc",
-            "js",
-            "ux"
-          ]
-        },
-        "hoursPerWeek": {
-          "type": "integer"
-        },
-        "start": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "end": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "format": "date-time"
-        },
-        "uid": {
-          "type": "string"
-        },
-        "cohortId": {
-          "type": "integer"
-        },
-        "contract": {
-          "$ref": "#/definitions/Contract"
-        }
-      }
-    }
-  },
-  "type": "object",
-  "properties": {
-    "country": {
-      "$ref": "#/definitions/Country"
-    },
-    "contract": {
-      "$ref": "#/definitions/Contract"
-    },
-    "gig": {
-      "$ref": "#/definitions/Gig"
-    }
-  }
-}