@laboratoria/sdk-js 0.1.1 → 1.2.0

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": {
@@ -75,7 +92,8 @@
           ]
         },
         "disabled": {
-          "type": "boolean"
+          "type": "boolean",
+          "default": false
         },
         "students": {
           "type": "array",
@@ -98,6 +116,18 @@
               "type": "null"
             }
           ]
+        },
+        "contracts": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Contract"
+          }
+        },
+        "gigs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Gig"
+          }
         }
       }
     },
@@ -228,6 +258,29 @@
           "type": "string",
           "format": "date-time"
         },
+        "vacancies": {
+          "type": [
+            "integer",
+            "null"
+          ]
+        },
+        "publicAdmission": {
+          "type": "boolean",
+          "default": false
+        },
+        "placementStart": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "format": "date-time"
+        },
+        "placementDuration": {
+          "type": [
+            "integer",
+            "null"
+          ]
+        },
         "program": {
           "$ref": "#/definitions/Program"
         },
@@ -246,20 +299,26 @@
             "$ref": "#/definitions/Dropout"
           }
         },
+        "gigs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Gig"
+          }
+        },
         "links": {
           "type": "array",
           "items": {
             "$ref": "#/definitions/CohortLink"
           }
         },
-        "legacySlug": {
-          "type": "string"
-        },
-        "signupUser": {
+        "signupUsers": {
           "type": "array",
           "items": {
             "$ref": "#/definitions/User"
           }
+        },
+        "legacySlug": {
+          "type": "string"
         }
       }
     },
@@ -283,7 +342,7 @@
             "null"
           ]
         },
-        "studentCode": {
+        "legacyStudentCode": {
           "type": [
             "string",
             "null"
@@ -346,15 +405,27 @@
           "format": "date-time"
         },
         "reason": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "dropout",
+            "noShow",
+            "invitedToLeave",
+            "changeCohort"
+          ]
         },
         "reasonDetail": {
-          "type": "string"
+          "type": [
+            "string",
+            "null"
+          ]
         },
-        "project": {
-          "type": "string"
+        "lastProject": {
+          "type": [
+            "string",
+            "null"
+          ]
         },
-        "stage": {
+        "completedProjects": {
           "type": "integer"
         },
         "notes": {
@@ -379,10 +450,133 @@
           "$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"
+        },
+        "currency": {
+          "type": "string",
+          "enum": [
+            "BRL",
+            "CLP",
+            "COP",
+            "MXN",
+            "PEN",
+            "USD"
+          ]
+        },
+        "feeBasis": {
+          "type": "string",
+          "enum": [
+            "HOURLY",
+            "MONTHLY"
+          ]
+        },
+        "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"
     },
@@ -406,6 +600,12 @@
     },
     "dropout": {
       "$ref": "#/definitions/Dropout"
+    },
+    "contract": {
+      "$ref": "#/definitions/Contract"
+    },
+    "gig": {
+      "$ref": "#/definitions/Gig"
     }
   }
 }

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,215 +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',
-    });
-  });
-});
-
-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');
-  });
-});