@laboratoria/sdk-js 3.4.1 → 4.0.0-alpha.1

package/lib/core.js

@@ -177,16 +177,19 @@ const extended = {
       'locality',
       'nationality',
       'isAllowedToWork',
+      'hasValidIdDocument',
       'householdSize',
       'children',
       'householdIncome',
       'educationLevel',
+      'schoolType',
       'educationSubject',
       'university',
       'isStudying',
       'workStatus',
       'isLookingForWork',
       'monthsLookingForWork',
+      'monthsUnemployed',
       'workRole',
       'freelance',
       'workFormal',
@@ -196,7 +199,13 @@ const extended = {
     ],
     properties: {
       locality: {
-        required: true,
+        isRequired: true,
+      },
+      isReady: {
+        isRequired: false,
+      },
+      bypassFilters: {
+        isRequired: false,
       },
     },
   },

package/lib/model.js

@@ -1,63 +1,44 @@
 import { createClient } from './client.js';
 
 
-const isRequiredOneToOneRelation = (schema, key) => (
-  !!schema.properties
-  && !!schema.properties[key]
-  && !!schema.properties[key].$ref
-);
-
-const isOptionalOneToOneRelation = (schema, key) => (
-  !!schema.properties
-  && !!schema.properties[key]
-  && Array.isArray(schema.properties[key].anyOf)
-  && !!schema.properties[key].anyOf[0]?.$ref
-  && schema.properties[key].anyOf[1]?.type === 'null'
-);
-
-// const isOneToOneRelation = (schema, key) => (
-//   isRequiredOneToOneRelation(schema, key)
-//   || isOptionalOneToOneRelation(schema, key)
-// );
-
-const isOneToManyRelation = (schema, key) => (
-  schema.properties
-  && schema.properties[key]
-  && schema.properties[key].type === 'array'
-  && !!schema.properties[key].items?.$ref
-);
-
-// const isRelation = (schema, key) => (
-//   isOneToOneRelation(schema, key)
-//   || isOneToManyRelation(schema, key)
-// );
-
-
 const createValidator = (schema) => {
   const properties = schema.properties || {};
   const inputProps = schema.inputProps || Object.keys(properties);
 
   const validateAttr = (key, value) => {
-    const attrSchema = properties[key] || {};
+    const propSchema = properties[key] || {};
+    const isNullVal = [null, undefined].includes(value);
 
-    if (attrSchema.enum) {
-      if (!attrSchema.required && !value) {
+    if (isNullVal) {
+      if (!propSchema.isRequired) {
         return;
       }
-      if (!attrSchema.enum.includes(value)) {
-        return {
-          id: 'enum-validation-error',
-          values: { enum: attrSchema.enum, value },
-        };
+
+      return { id: 'required-validation-error' };
+    }
+
+    if (propSchema.enum) {
+      if (propSchema.enum.includes(value)) {
+        return;
       }
+      return {
+        id: 'enum-validation-error',
+        values: { enum: propSchema.enum, value },
+      };
     }
 
-    switch (attrSchema.$type) {
+    switch (propSchema.type) {
       case 'integer':
-        const parsedValue = parseInt(value, 10);
-        if (attrSchema.required && Number.isNaN(parsedValue)) {
+        if (propSchema.isScalar && (typeof value !== 'number' || Number.isNaN(value))) {
           return { id: 'invalid-number-validation-error' };
         }
+        // if (propSchema.isRequired && Number.isNaN(parsedValue)) {
+        //   return { id: 'invalid-number-validation-error' };
+        // }
+        // const parsedValue = parseInt(value, 10);
+        // if (propSchema.isRequired && Number.isNaN(parsedValue)) {
+        //   return { id: 'invalid-number-validation-error' };
+        // }
         break;
       case 'date':
         break;
@@ -65,9 +46,8 @@ const createValidator = (schema) => {
         break;
       case 'json':
       case 'string':
-      case 'ref':
       default:
-        if (attrSchema.required && !value) {
+        if (propSchema.isRequired && !value) {
           return { id: 'required-validation-error' };
         }
         break;
@@ -120,7 +100,9 @@ const serializeData = (data, schema) => {
       if (hasInputProps && !schema.inputProps.includes(key)) {
         return memo;
       }
-      if (isOptionalOneToOneRelation(schema, key) && data[key] === null) {
+      // TODO: Deberíamos incluir props que no aparecen en el schema??
+      const { isRef, isScalar, isRequired } = schema.properties[key] || {};
+      if (isRef && isScalar && !isRequired && data[key] === null) {
         return memo;
       }
       return {
@@ -139,38 +121,43 @@ const parseSchema = ({ primaryKey, properties, ...rest }) => {
     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 { type, isScalar, isRequired, isRef = false } = (
+          typeof propSchema.type === 'string'
+            ? propSchema.type === 'array'
+              ? !!propSchema.enum
+                ? { type: 'string', isScalar: false, isRequired: false }
+                : !!propSchema.items?.$ref
+                  ? { type: propSchema.items.$ref.split('/').pop(), isScalar: false, isRequired: false, isRef: true }
+                  : { type: propSchema.items?.type, isScalar: false, isRequired: false }
+              : { type: propSchema.format === 'date-time' ? 'date' : propSchema.type, isScalar: true, isRequired: true }
+            : Array.isArray(propSchema.type)
+              ? propSchema.type.length === 2
+                ? { type: propSchema.format === 'date-time' ? 'date' : propSchema.type[0], isScalar: true, isRequired: false }
+                : { type: 'json', isScalar: true, isRequired: propSchema.type.includes('null') }
+              : !!propSchema.$ref
+                ? { type: propSchema.$ref.split('/').pop(), isScalar: true, isRequired: true, isRef: true }
+                : { type: propSchema.anyOf[0].$ref.split('/').pop(), isScalar: true, isRequired: false, isRef: true }
         );
+
         const inputType = propSchema.inputType || (
-          $type === 'integer'
+          type === 'integer'
             ? 'number'
-            : $type === 'string' && propSchema.format === 'date-time'
-              ? 'date'
-              : $type
+            : type
         );
+
         return {
           ...memo,
           [key]: {
             ...properties[key],
-            $type,
-            inputType,
-            required: (
-              typeof propSchema.required === 'boolean'
-                ? propSchema.required
-                : (
-                  !Array.isArray(propSchema.type)
-                  || !propSchema.type.includes('null')
-                )
+            type,
+            isScalar,
+            isRequired: (
+              typeof propSchema.isRequired === 'boolean'
+                ? propSchema.isRequired
+                : isRequired
             ),
+            isRef,
+            inputType,
           },
         };
       },
@@ -205,7 +192,7 @@ export const createModel = (
     });
   };
 
-  const parse = data => {
+  const parse = (data) => {
     if (!data) {
       return data;
     }
@@ -213,37 +200,30 @@ export const createModel = (
     const parsed = Object.keys(data).reduce(
       (memo, key) => {
         const propSchema = properties[key] || {};
-        const { type, format, items } = propSchema;
-        if (items && isOneToManyRelation(parsedSchema, key)) {
-          const relationModelName = lcFirst(items.$ref.split('/').pop());
-          return {
-            ...memo,
-            [key]: (
-              typeof models[relationModelName]?.parse === 'function'
-                ? data[key].map(obj => models[relationModelName].parse(obj))
-                : data[key]
-            ),
-          };
-        }
-        const ref = (
-          isRequiredOneToOneRelation(parsedSchema, key)
-            ? propSchema.$ref
-            : isOptionalOneToOneRelation(parsedSchema, key)
-              ? propSchema.anyOf[0]?.$ref
-              : null
-        );
-
-        if (ref) {
-          const relationModelName = lcFirst(ref.split('/').pop());
+        const { type, isScalar, isRef, format, items } = propSchema;
+
+        if (isRef) {
+          const relationModelName = lcFirst(type);
+          if (!isScalar) {
+            return {
+              ...memo,
+              [key]: (
+                typeof models[relationModelName]?.parse === 'function'
+                  ? data[key].map(obj => models[relationModelName].parse(obj))
+                  : data[key]
+              ),
+            };
+          }
           return {
             ...memo,
             [key]: models[relationModelName].parse(data[key]),
           };
         }
+
         return {
           ...memo,
           [key]: (
-            format === 'date-time' && data[key]
+            type === 'date' && data[key]
               ? new Date(data[key])
               : data[key]
           ),
@@ -251,6 +231,7 @@ export const createModel = (
       },
       {},
     );
+
     return (
       typeof parsedSchema.parse === 'function'
         ? parsedSchema.parse(parsed)
@@ -260,19 +241,22 @@ export const createModel = (
 
   const relations = Object.keys(properties || {}).reduce(
     (memo, key) => (
-      isRequiredOneToOneRelation(parsedSchema, key)
+      properties[key].isRef && properties[key].isScalar && properties[key].isRequired
+        // isRequiredOneToOneRelation(parsedSchema, key)
         ? Object.assign(memo, {
           all: memo.all.concat(key),
           oneToOne: memo.oneToOne.concat(key),
           requiredOneToOne: memo.requiredOneToOne.concat(key),
         })
-        : isOptionalOneToOneRelation(parsedSchema, key)
+        // : isOptionalOneToOneRelation(parsedSchema, key)
+        : properties[key].isRef && properties[key].isScalar
           ? Object.assign(memo, {
             all: memo.all.concat(key),
             oneToOne: memo.oneToOne.concat(key),
             optionalOneToOne: memo.optionalOneToOne.concat(key),
           })
-          : isOneToManyRelation(parsedSchema, key)
+          // : isOneToManyRelation(parsedSchema, key)
+          : properties[key].isRef
             ? Object.assign(memo, {
               all: memo.all.concat(key),
               oneToMany: memo.oneToMany.concat(key),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "3.4.1",
+  "version": "4.0.0-alpha.1",
   "description": "Laboratoria JavaScript (browser) SDK",
   "license": "MIT",
   "scripts": {

package/schemas/core.json

@@ -711,6 +711,9 @@
         "isAllowedToWork": {
           "type": "boolean"
         },
+        "hasValidIdDocument": {
+          "type": "boolean"
+        },
         "locality": {
           "type": [
             "number",
@@ -730,6 +733,17 @@
         "householdIncome": {
           "type": "integer"
         },
+        "schoolType": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "enum": [
+            "private",
+            "public",
+            "other"
+          ]
+        },
         "educationSubject": {
           "type": [
             "string",
@@ -777,6 +791,12 @@
             "null"
           ]
         },
+        "monthsUnemployed": {
+          "type": [
+            "integer",
+            "null"
+          ]
+        },
         "workRole": {
           "type": [
             "string",