@laboratoria/sdk-js 0.1.0 → 1.1.0

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

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"
-    }
-  }
-}