@laboratoria/sdk-js 1.2.0 → 1.5.0

package/index.js

@@ -59,5 +59,6 @@ export const createApp = ({
     ...curriculumAPI,
     ...coreAPI,
     auth: authAPI,
+    firebaseApp,
   };
 };

package/lib/core.js

@@ -14,6 +14,7 @@ const extended = {
       'firstName',
       'lastName',
       'email',
+      'password',
       'lang',
       'github',
       'linkedin',
@@ -123,15 +124,20 @@ const extended = {
     inputProps: [
       'user',
       'country',
-      'currency',
       'isEmployment',
-      'feeBasis',
       'feeAmount',
       '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.2.0",
+  "version": "1.5.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "scripts": {
     "test": "jest --verbose --coverage",
@@ -9,24 +9,24 @@
   "license": "MIT",
   "dependencies": {
     "blueimp-md5": "^2.19.0",
-    "firebase": "^9.6.5"
+    "firebase": "^9.6.8"
   },
   "devDependencies": {
-    "@babel/core": "^7.17.0",
+    "@babel/core": "^7.17.5",
     "@babel/plugin-transform-modules-commonjs": "^7.16.8",
-    "babel-jest": "^27.4.6",
-    "jest": "^27.4.7",
-    "webpack": "^5.68.0",
+    "babel-jest": "^27.5.1",
+    "jest": "^27.5.1",
+    "webpack": "^5.70.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": {
@@ -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"
         },