@laboratoria/sdk-js 5.3.1 → 6.0.0-beta.0

package/lib/model.js

@@ -1,343 +0,0 @@
-import { createClient } from './client.js';
-
-
-const createValidator = (schema) => {
-  const properties = schema.properties || {};
-  const inputProps = schema.inputProps || Object.keys(properties);
-
-  const validateAttr = (key, value) => {
-    const propSchema = properties[key] || {};
-    const isNullVal = [null, undefined].includes(value);
-
-    if (isNullVal) {
-      if (!propSchema.isRequired) {
-        return;
-      }
-
-      return { id: 'value-missing-validation-error' };
-    }
-
-    if (propSchema.enum) {
-      if (propSchema.enum.includes(value)) {
-        return;
-      }
-      return {
-        id: 'enum-validation-error',
-        values: { enum: propSchema.enum, value },
-      };
-    }
-
-    switch (propSchema.type) {
-      case 'integer':
-        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;
-      case 'boolean':
-        break;
-      case 'json':
-      case 'string':
-      default:
-        if (propSchema.isRequired && !value) {
-          return { id: 'value-missing-validation-error' };
-        }
-        break;
-    }
-  };
-
-  return {
-    validate: attrs => inputProps.reduce(
-      (memo, key) => {
-        const err = validateAttr(key, attrs[key]);
-        if (err) {
-          return { ...memo, [key]: err };
-        }
-        return memo;
-      },
-      {},
-    ),
-    validateAttr,
-  };
-};
-
-
-const qToQs = (q = {}) => Object.keys(q).length ? `?q=${JSON.stringify(q)}` : '';
-
-
-const toKebabCase = (str) => [...str].reduce(
-  (memo, char) => (
-    char === char.toUpperCase()
-      ? `${memo}-${char.toLowerCase()}`
-      : `${memo}${char}`
-  ),
-  '',
-);
-
-const lcFirst = str => `${str[0].toLowerCase()}${str.slice(1)}`;
-
-
-const createBuildURL = (collectionName) => {
-  const base = toKebabCase(collectionName);
-  return (id, q) => {
-    return `/${base}${id ? `/${encodeURIComponent(id)}` : ''}${qToQs(q)}`;
-  };
-};
-
-
-const serializeData = (data, schema) => {
-  const hasInputProps = Array.isArray(schema.inputProps);
-  return Object.keys(data).reduce(
-    (memo, key) => {
-      if (hasInputProps && !schema.inputProps.includes(key)) {
-        return memo;
-      }
-      // 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 {
-        ...memo,
-        [key]: data[key],
-      };
-    },
-    {},
-  );
-};
-
-
-const parseSchema = ({ primaryKey, properties, ...rest }) => {
-  return {
-    primaryKey: primaryKey || 'id',
-    properties: Object.keys(properties || {}).reduce(
-      (memo, key) => {
-        const propSchema = properties[key] || {};
-        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'
-            ? 'number'
-            : type
-        );
-
-        return {
-          ...memo,
-          [key]: {
-            ...properties[key],
-            type,
-            isScalar,
-            isRequired: (
-              typeof propSchema.isRequired === 'boolean'
-                ? propSchema.isRequired
-                : isRequired
-            ),
-            isRef,
-            inputType,
-          },
-        };
-      },
-      {},
-    ),
-    ...rest,
-  };
-};
-
-
-export const createModel = (
-  baseUrl,
-  state,
-  collectionName,
-  schema = {},
-  models = {},
-) => {
-  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, parsedSchema),
-  });
-  const put = ({ data, ...q }) => {
-    const { where, ...rest } = q;
-    return req(buildURL(where[primaryKey], rest), {
-      method: 'PUT',
-      body: serializeData(data, parsedSchema),
-    });
-  };
-
-  const parse = (data) => {
-    if (!data) {
-      return data;
-    }
-
-    const parsed = Object.keys(data).reduce(
-      (memo, key) => {
-        const propSchema = properties[key] || {};
-        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]: (
-            type === 'date' && data[key]
-              ? new Date(data[key])
-              : data[key]
-          ),
-        };
-      },
-      {},
-    );
-
-    return (
-      typeof parsedSchema.parse === 'function'
-        ? parsedSchema.parse(parsed)
-        : parsed
-    );
-  };
-
-  const relations = Object.keys(properties || {}).reduce(
-    (memo, key) => (
-      properties[key].isRef && properties[key].isScalar && properties[key].isRequired
-        ? Object.assign(memo, {
-          all: memo.all.concat(key),
-          oneToOne: memo.oneToOne.concat(key),
-          requiredOneToOne: memo.requiredOneToOne.concat(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),
-          })
-          : properties[key].isRef
-            ? Object.assign(memo, {
-              all: memo.all.concat(key),
-              oneToMany: memo.oneToMany.concat(key),
-            })
-            : memo
-    ),
-    {
-      all: [],
-      oneToOne: [],
-      requiredOneToOne: [],
-      optionalOneToOne: [],
-      oneToMany: [],
-    },
-  );
-
-  return {
-    get schema() {
-      return parsedSchema;
-    },
-    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(parse),
-    create,
-    update: put,
-    upsert: opts => (
-      !opts.where[primaryKey]
-        ? create({ data: opts.create })
-        : 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 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) => ({
-      ...memo,
-      [key]: (
-        !extended[key]
-          ? schema.definitions[key]
-          : {
-            ...schema.definitions[key],
-            ...extended[key],
-            properties: Object.keys(schema.definitions[key].properties).reduce(
-              (prev, propName) => ({
-                ...prev,
-                [propName]: {
-                  ...schema.definitions[key].properties[propName],
-                  ...(extended[key].properties || {})[propName],
-                },
-              }),
-              extended[key].properties || {},
-            ),
-          }
-      ),
-    }),
-    {},
-  );
-};

package/lib/roles.js

@@ -1,10 +0,0 @@
-const roles = ['bm', 'pdc', 'js', 'ux'];
-
-roles.colors = {
-  bm: 'black',
-  pdc: 'magenta',
-  js: 'primary',
-  ux: 'mint',
-};
-
-export default roles;

package/lib/util.js

@@ -1,68 +0,0 @@
-const pad = n => n > 9 ? `${n}` : `0${n}`;
-
-export const formatDate = date => (
-  `${pad(date.getUTCDate())}/${pad(date.getUTCMonth() + 1)}/${date.getUTCFullYear()}`
-);
-
-export const formatTime = date => (
-  `${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${date.getUTCSeconds()} UTC`
-);
-
-export const formatDateTime = date => `${formatDate(date)} ${formatTime(date)}`;
-
-const locales = {
-  es: 'es-ES',
-  pt: 'pt-BR',
-};
-
-export const formatMonth = (date, lang = 'es', showYear = false) => {
-  return new Intl.DateTimeFormat(locales[lang], {
-    ...(showYear && {
-      year: 'numeric',
-    }),
-    month: 'long',
-    day: 'numeric',
-    timeZone: 'UTC',
-  }).format(new Date(date));
-};
-
-export const getAgeAt = (dateOfBirth, at) => {
-  let age = at.getFullYear() - dateOfBirth.getFullYear();
-  const m = at.getMonth() - dateOfBirth.getMonth();
-
-  if (m < 0 || (m === 0 && at.getDate() < dateOfBirth.getDate())) {
-    age--;
-  }
-
-  return age;
-};
-
-const createCurrencyFormatter = (
-  lang,
-  countryCode,
-  currencyCode,
-) => new Intl.NumberFormat(
-  `${lang}-${countryCode}`,
-  { currency: currencyCode },
-);
-
-export const formatCurrency = (
-  val,
-  lang,
-  countryCode,
-  currencyCode,
-) => createCurrencyFormatter(
-  lang,
-  countryCode,
-  currencyCode,
-).format(val);
-
-export const parseCurrency = val => parseInt(val.replace(/[,\.]/g, ''), 10);
-
-export const loadFromLocalStorage = (path) => {
-  try {
-    return JSON.parse(window.localStorage.getItem(path));
-  } catch (_) {
-    return null;
-  }
-};