@laboratoria/sdk-js 3.2.1 → 3.4.0

package/lib/core.js

@@ -39,6 +39,9 @@ const extended = {
       email: {
         inputType: 'email',
       },
+      mobileNumber: {
+        inputType: 'phone',
+      },
       bio: {
         inputType: 'textarea',
       },
@@ -179,8 +182,8 @@ const extended = {
       'householdIncome',
       'educationLevel',
       'educationSubject',
+      'university',
       'isStudying',
-      'isDegreeFromListedInstitutions',
       'workStatus',
       'isLookingForWork',
       'monthsLookingForWork',
@@ -189,9 +192,13 @@ const extended = {
       'workFormal',
       'workIncome',
       'isReady',
-      // 'isReturningApplicant',
-      // 'legacyAdmissionCohortSlug',
+      'bypassFilters',
     ],
+    properties: {
+      locality: {
+        required: true,
+      },
+    },
   },
   IscedLevel: {
     parse: (props) => {
@@ -208,6 +215,10 @@ const extended = {
       'label',
     ],
   },
+  University: {
+    plural: 'universities',
+    searchProps: ['name'],
+  },
 };
 
 export const createAPI = (url, state) => ({

package/lib/model.js

@@ -39,43 +39,38 @@ const createValidator = (schema) => {
 
   const validateAttr = (key, value) => {
     const attrSchema = properties[key] || {};
-    const type = (
-      Array.isArray(attrSchema.type)
-        ? attrSchema.type[0]
-        : attrSchema.type
-    );
-    const isRequired = (
-      !Array.isArray(attrSchema.type)
-      || !attrSchema.type.includes('null')
-    );
 
     if (attrSchema.enum) {
-      if (!isRequired && !value) {
+      if (!attrSchema.required && !value) {
         return;
       }
       if (!attrSchema.enum.includes(value)) {
-        return `${value} is not one of: ${attrSchema.enum.join(',')}`;
+        return {
+          id: 'enum-validation-error',
+          values: { enum: attrSchema.enum, value },
+        };
       }
     }
 
-    switch (type) {
-      case 'string':
-        if (isRequired && !value) {
-          return 'Field is required';
-        }
-        break;
+    switch (attrSchema.$type) {
       case 'integer':
         const parsedValue = parseInt(value, 10);
-        if (isRequired && Number.isNaN(parsedValue)) {
-          return 'Invalid number format';
+        if (attrSchema.required && Number.isNaN(parsedValue)) {
+          return { id: 'invalid-number-validation-error' };
         }
         break;
       case 'date':
         break;
       case 'boolean':
         break;
+      case 'json':
+      case 'string':
+      case 'ref':
       default:
-      // ...
+        if (attrSchema.required && !value) {
+          return { id: 'required-validation-error' };
+        }
+        break;
     }
   };
 
@@ -138,6 +133,54 @@ const serializeData = (data, schema) => {
 };
 
 
+const parseSchema = ({ primaryKey, properties, ...rest }) => {
+  return {
+    primaryKey: primaryKey || 'id',
+    properties: Object.keys(properties || {}).reduce(
+      (memo, key) => {
+        const propSchema = properties[key] || {};
+        const $type = (
+          !propSchema.type
+            ? propSchema.$ref
+              ? 'ref'
+              : undefined
+            : !Array.isArray(propSchema.type)
+              ? propSchema.type
+              : propSchema.type.length < 3
+                ? propSchema.type[0]
+                : 'json'
+        );
+        const inputType = propSchema.inputType || (
+          $type === 'integer'
+            ? 'number'
+            : $type === 'string' && propSchema.format === 'date-time'
+              ? 'date'
+              : $type
+        );
+        return {
+          ...memo,
+          [key]: {
+            ...properties[key],
+            $type,
+            inputType,
+            required: (
+              typeof propSchema.required === 'boolean'
+                ? propSchema.required
+                : (
+                  !Array.isArray(propSchema.type)
+                  || !propSchema.type.includes('null')
+                )
+            ),
+          },
+        };
+      },
+      {},
+    ),
+    ...rest,
+  };
+};
+
+
 export const createModel = (
   baseUrl,
   state,
@@ -145,19 +188,20 @@ export const createModel = (
   schema = {},
   models = {},
 ) => {
-  const primaryKey = schema.primaryKey || 'id';
-  const validator = createValidator(schema);
+  const parsedSchema = parseSchema(schema);
+  const { primaryKey, properties } = parsedSchema;
+  const validator = createValidator(parsedSchema);
   const buildURL = createBuildURL(collectionName);
   const req = (...args) => createClient(baseUrl, state.authUser)(...args);
   const create = ({ data, ...q }) => req(buildURL(null, q), {
     method: 'POST',
-    body: serializeData(data, schema),
+    body: serializeData(data, parsedSchema),
   });
   const put = ({ data, ...q }) => {
     const { where, ...rest } = q;
     return req(buildURL(where[primaryKey], rest), {
       method: 'PUT',
-      body: serializeData(data, schema),
+      body: serializeData(data, parsedSchema),
     });
   };
 
@@ -168,9 +212,9 @@ export const createModel = (
 
     const parsed = Object.keys(data).reduce(
       (memo, key) => {
-        const propSchema = schema.properties[key] || {};
+        const propSchema = properties[key] || {};
         const { type, format, items } = propSchema;
-        if (items && isOneToManyRelation(schema, key)) {
+        if (items && isOneToManyRelation(parsedSchema, key)) {
           const relationModelName = lcFirst(items.$ref.split('/').pop());
           return {
             ...memo,
@@ -182,9 +226,9 @@ export const createModel = (
           };
         }
         const ref = (
-          isRequiredOneToOneRelation(schema, key)
+          isRequiredOneToOneRelation(parsedSchema, key)
             ? propSchema.$ref
-            : isOptionalOneToOneRelation(schema, key)
+            : isOptionalOneToOneRelation(parsedSchema, key)
               ? propSchema.anyOf[0]?.$ref
               : null
         );
@@ -208,27 +252,27 @@ export const createModel = (
       {},
     );
     return (
-      typeof schema.parse === 'function'
-        ? schema.parse(parsed)
+      typeof parsedSchema.parse === 'function'
+        ? parsedSchema.parse(parsed)
         : parsed
     );
   };
 
-  const relations = Object.keys(schema.properties || {}).reduce(
+  const relations = Object.keys(properties || {}).reduce(
     (memo, key) => (
-      isRequiredOneToOneRelation(schema, key)
+      isRequiredOneToOneRelation(parsedSchema, key)
         ? Object.assign(memo, {
           all: memo.all.concat(key),
           oneToOne: memo.oneToOne.concat(key),
           requiredOneToOne: memo.requiredOneToOne.concat(key),
         })
-        : isOptionalOneToOneRelation(schema, key)
+        : isOptionalOneToOneRelation(parsedSchema, key)
           ? Object.assign(memo, {
             all: memo.all.concat(key),
             oneToOne: memo.oneToOne.concat(key),
             optionalOneToOne: memo.optionalOneToOne.concat(key),
           })
-          : isOneToManyRelation(schema, key)
+          : isOneToManyRelation(parsedSchema, key)
             ? Object.assign(memo, {
               all: memo.all.concat(key),
               oneToMany: memo.oneToMany.concat(key),
@@ -246,7 +290,7 @@ export const createModel = (
 
   return {
     get schema() {
-      return { ...schema, primaryKey };
+      return parsedSchema;
     },
     get relations() {
       return relations;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "license": "MIT",
   "scripts": {
@@ -11,14 +11,14 @@
   },
   "dependencies": {
     "blueimp-md5": "^2.19.0",
-    "firebase": "^9.16.0"
+    "firebase": "^9.17.1"
   },
   "devDependencies": {
     "@babel/core": "^7.20.12",
     "@babel/plugin-transform-modules-commonjs": "^7.20.11",
-    "babel-jest": "^29.4.0",
-    "jest": "^29.4.0",
-    "jest-environment-jsdom": "^29.4.0",
+    "babel-jest": "^29.4.2",
+    "jest": "^29.4.2",
+    "jest-environment-jsdom": "^29.4.2",
     "webpack": "^5.75.0",
     "webpack-cli": "^5.0.1"
   },

package/schemas/core.json

@@ -645,6 +645,45 @@
         }
       }
     },
+    "University": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "updatedAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "countryCode": {
+          "type": "string"
+        },
+        "lang": {
+          "type": "string",
+          "enum": [
+            "en",
+            "es",
+            "pt"
+          ]
+        },
+        "name": {
+          "type": "string"
+        },
+        "filter": {
+          "type": "boolean"
+        },
+        "applications": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Application"
+          }
+        }
+      }
+    },
     "Application": {
       "type": "object",
       "properties": {
@@ -718,9 +757,6 @@
         "isStudying": {
           "type": "boolean"
         },
-        "isDegreeFromListedInstitutions": {
-          "type": "boolean"
-        },
         "workStatus": {
           "type": "string",
           "enum": [
@@ -781,6 +817,16 @@
             "null"
           ]
         },
+        "failedFilters": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "bypassFilters": {
+          "type": "boolean",
+          "default": false
+        },
         "isReady": {
           "type": "boolean",
           "default": false
@@ -812,6 +858,16 @@
         "educationLevel": {
           "$ref": "#/definitions/EducationLevel"
         },
+        "university": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/University"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "challengeAssignments": {
           "type": "array",
           "items": {
@@ -911,7 +967,8 @@
         "type": {
           "type": "string",
           "enum": [
-            "challenge"
+            "challenge",
+            "application_filter"
           ]
         },
         "data": {
@@ -1208,6 +1265,9 @@
     "educationLevel": {
       "$ref": "#/definitions/EducationLevel"
     },
+    "university": {
+      "$ref": "#/definitions/University"
+    },
     "application": {
       "$ref": "#/definitions/Application"
     },