@laboratoria/sdk-js 1.3.0 → 1.4.0

package/lib/core.js

@@ -128,8 +128,15 @@ const extended = {
       'hoursPerWeek',
       'start',
       'end',
+      'isTrial',
+      'checkPilot',
+      'source',
+    ],
+    searchProps: [
+      'user.firstName',
+      'user.lastName',
+      'user.email',
     ],
-    searchProps: ['user.firstName'],
     getOptionLabel: ({ id, user }) => `${user?.firstName} (id: ${id})`,
   },
   Gig: {

package/lib/model.js

@@ -15,10 +15,10 @@ const isOptionalOneToOneRelation = (schema, key) => (
   && schema.properties[key].anyOf[1]?.type === 'null'
 );
 
-const isOneToOneRelation = (schema, key) => (
-  isRequiredOneToOneRelation(schema, key)
-  || isOptionalOneToOneRelation(schema, key)
-);
+// const isOneToOneRelation = (schema, key) => (
+//   isRequiredOneToOneRelation(schema, key)
+//   || isOptionalOneToOneRelation(schema, key)
+// );
 
 const isOneToManyRelation = (schema, key) => (
   schema.properties
@@ -123,7 +123,7 @@ const serializeData = (data, schema) => {
 };
 
 
-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);
@@ -141,9 +141,40 @@ export const createModel = (baseUrl, state, collectionName, 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]: (
@@ -199,12 +230,13 @@ export const createModel = (baseUrl, state, collectionName, schema = {}) => {
     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 => (
@@ -213,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) => ({
@@ -259,4 +294,4 @@ export const extendSchemaDefinitions = (schema, extended) => {
     }),
     {},
   );
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "scripts": {
     "test": "jest --verbose --coverage",
@@ -12,21 +12,21 @@
     "firebase": "^9.6.6"
   },
   "devDependencies": {
-    "@babel/core": "^7.17.2",
+    "@babel/core": "^7.17.4",
     "@babel/plugin-transform-modules-commonjs": "^7.16.8",
     "babel-jest": "^27.5.1",
     "jest": "^27.5.1",
-    "webpack": "^5.68.0",
+    "webpack": "^5.69.0",
     "webpack-cli": "^4.9.2"
   },
   "jest": {
     "testEnvironment": "jsdom",
     "coverageThreshold": {
       "global": {
-        "statements": 97,
-        "branches": 92,
+        "statements": 96.9,
+        "branches": 94,
         "functions": 98,
-        "lines": 97
+        "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": {
@@ -488,9 +494,37 @@
         "feeAmount": {
           "type": "integer"
         },
+        "isTrial": {
+          "type": "boolean",
+          "default": false
+        },
+        "source": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "enum": [
+            "graduate",
+            "referral",
+            "jazzhr",
+            "web",
+            "linkedin",
+            "other"
+          ]
+        },
         "user": {
           "$ref": "#/definitions/User"
         },
+        "checkPilot": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/User"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "country": {
           "$ref": "#/definitions/Country"
         },