@laboratoria/sdk-js 0.1.1 → 1.2.0

package/README.md

@@ -1,5 +1,7 @@
 ## Laboratoria JavaScript (browser) SDK
 
+[![Node.js CI](https://github.com/Laboratoria/sdk-js/actions/workflows/node.js.yml/badge.svg)](https://github.com/Laboratoria/sdk-js/actions/workflows/node.js.yml)
+
 :warning: This tool is still in draft stage and is likely to change without
 notice.
 
@@ -25,7 +27,6 @@ const app = createApp({
   firebaseApiKey: '',
   firebaseProject: '',
   coreApiUrl: '',
-  teamApiUrl: '',
   jobsApiUrl: '',
 });
 ```
@@ -79,7 +80,6 @@ app.user.create({
 ### Cohorts
 
 ```js
-// Cohorts API
 app.cohort.findMany({
   where: {
     end: { gt: new Date() },
@@ -96,13 +96,50 @@ app.cohort.findMany({
 
 ### Students
 
+WIP
+
 ### Dropouts
 
+WIP
 
 ### Projects
 
 ```js
 app.project.findMany();
 
-// app.learningObjectives.
+app.project.findMany({ tag: 'v3.0.0' });
+
+app.project.findMany({
+  locale: 'es-ES',
+  track: 'js',
+});
+
+app.project.findById('cipher');
+
+app.project.findById('cipher', { tag: 'v3.0.0' });
 ```
+
+### Topics
+
+```js
+app.topic.findMany();
+
+app.topic.findMany({ tag: 'v3.0.0' });
+
+app.topic.findMany({
+  locale: 'es-ES',
+  track: 'js',
+});
+
+app.topic.findById('javascript');
+
+app.topic.findById('javascript', { tag: 'v3.0.0' });
+```
+
+### Learning Objectives
+
+```js
+app.learningObjective.findMany();
+
+app.learningObjective.findMany({ tag: 'v3.0.0' });
+```

package/index.js

@@ -5,16 +5,14 @@ import {
   signInWithEmailAndPassword,
   signOut,
 } from 'firebase/auth';
-import { createClient } from './lib/client';
 import { createAPI as createCoreAPI } from './lib/core';
+import { createAPI as createCurriculumAPI } from './lib/curriculum';
 import { createAPI as createJobsAPI } from './lib/jobs';
-import { createAPI as createTeamAPI } from './lib/team';
 
 export const createApp = ({
   firebaseApiKey = 'AIzaSyAXbaEbpq8NOfn0r8mIrcoHvoGRkJThwdc',
   firebaseProject = 'laboratoria-la',
   coreApiUrl = 'https://us-central1-outpost-272720.cloudfunctions.net/core-api',
-  teamApiUrl = 'https://us-central1-outpost-272720.cloudfunctions.net/team-api',
   jobsApiUrl = 'https://us-central1-outpost-272720.cloudfunctions.net/jobs-api',
 } = {}) => {
   const firebaseApp = initializeApp({
@@ -26,31 +24,25 @@ export const createApp = ({
 
   const firebaseAuth = getAuth(firebaseApp);
   const state = { authUser: undefined, user: undefined };
-
-  const setState = (authUser, user) => {
-    Object.assign(state, { authUser, user });
-  };
+  const coreAPI = createCoreAPI(coreApiUrl, state);
+  const jobsAPI = createJobsAPI(jobsApiUrl, state);
+  const curriculumAPI = createCurriculumAPI();
 
   const authAPI = {
     onChange: fn => onAuthStateChanged(firebaseAuth, (authUser) => {
       if (!authUser) {
-        setState(null, null);
+        Object.assign(state, { authUser: null, user: null });
         return fn(state);
       }
-      createClient(coreApiUrl, authUser)(`/users/${authUser.uid}`)
+      Object.assign(state, { authUser });
+      coreAPI.user.findById(authUser.uid)
         .then((user) => {
-          Object.assign(user, {
-            isStaff: ['staff', 'manager', 'finance', 'admin'].includes(user.role),
-            isManager: ['manager', 'finance', 'admin'].includes(user.role),
-            isFinance: ['finance', 'admin'].includes(user.role),
-            isAdmin: user.role === 'admin',
-          });
-          setState(authUser, user);
+          Object.assign(state, { user });
           fn(state);
         })
         .catch((err) => {
           console.error(err);
-          setState(null, null)
+          Object.assign(state, { authUser: null, user: null });
           fn(state);
         });
     }),
@@ -63,9 +55,9 @@ export const createApp = ({
   };
 
   return {
+    ...jobsAPI,
+    ...curriculumAPI,
+    ...coreAPI,
     auth: authAPI,
-    ...createJobsAPI(jobsApiUrl, state),
-    ...createTeamAPI(teamApiUrl, state),
-    ...createCoreAPI(coreApiUrl, state),
   };
 };

package/lib/core.js

@@ -1,14 +1,20 @@
+import md5 from 'blueimp-md5';
 import { createModels, extendSchemaDefinitions } from './model';
 import schema from '../schemas/core.json';
 
 const extended = {
+  Country: {
+    primaryKey: 'code',
+    plural: 'countries',
+    searchProps: ['code', 'name'],
+  },
   User: {
     primaryKey: 'uid',
     inputProps: [
       'firstName',
       'lastName',
       'email',
-      'locale',
+      'lang',
       'github',
       'linkedin',
       'bio',
@@ -22,17 +28,24 @@ const extended = {
       email: {
         inputType: 'email',
       },
-      locale: {
-        enum: ['es-ES', 'pt-BR'],
-      },
       bio: {
         inputType: 'textarea',
       },
     },
     parse: (props) => {
+      const avatar = (
+        props.github
+          ? `https://github.com/${props.github}.png?size=`
+          : `https://www.gravatar.com/avatar/${md5(props.email)}?s=`
+      )
       return {
         ...props,
         fullName: `${props.firstName} ${props.lastName}`,
+        avatar: size => `${avatar}${size}`,
+        isStaff: ['staff', 'manager', 'finance', 'admin'].includes(props.role),
+        isManager: ['manager', 'finance', 'admin'].includes(props.role),
+        isFinance: ['finance', 'admin'].includes(props.role),
+        isAdmin: props.role === 'admin',
       };
     },
   },
@@ -59,6 +72,27 @@ const extended = {
       `${name}${!stage ? '' : ` - ${stage.name}`} (id: ${id})`
     ),
     properties: {},
+    parse: (props) => {
+      const now = Date.now();
+      // TODO: Handle case where start and/or end have not been  selected in query
+      const status = (
+        props.start > now
+          ? 'upcoming'
+          : props.end < now
+            ? 'past'
+            : 'active'
+      );
+      const size = (
+        status === 'upcoming' && props.vacancies
+          ? props.vacancies
+          : props._count?.students || props.students?.length || 0
+      );
+      return {
+        ...props,
+        status,
+        size,
+      };
+    },
   },
   Student: {
     inputProps: [],
@@ -71,8 +105,8 @@ const extended = {
       'date',
       'reason',
       'reasonDetail',
-      'project',
-      'stage',
+      'lastProject',
+      'completedProjects',
       'notes',
       'staffSad',
       'covidRelated',
@@ -85,14 +119,35 @@ const extended = {
       'cohort.name',
     ],
   },
+  Contract: {
+    inputProps: [
+      'user',
+      'country',
+      'currency',
+      'isEmployment',
+      'feeBasis',
+      'feeAmount',
+      'hoursPerWeek',
+      'start',
+      'end',
+    ],
+    searchProps: ['user.firstName'],
+    getOptionLabel: ({ id, user }) => `${user?.firstName} (id: ${id})`,
+  },
+  Gig: {
+    inputProps: [
+      'cohort',
+      'user',
+      'contract',
+      'role',
+      'hoursPerWeek',
+      'start',
+      'end',
+    ],
+  },
 };
 
 export const createAPI = (url, state) => createModels(url, state, {
   ...schema,
   definitions: extendSchemaDefinitions(schema, extended),
 });
-
-// const {
-//   delete: _,
-//   ...userAPI,
-// } = createModel(coreApiUrl, state, 'users', schemas.user);

package/lib/curriculum.js

@@ -0,0 +1,59 @@
+const releasesUrl = 'https://api.github.com/repos/Laboratoria/bootcamp/releases';
+const rawUrl = 'https://raw.githubusercontent.com/Laboratoria/bootcamp';
+
+const getLatestVersion = () => fetch(`${releasesUrl}/latest`)
+  .then(resp => resp.json())
+  .then(({ tag_name }) => tag_name);
+
+const fetchProjects = async tag => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/projects.json`)
+    .then(resp => resp.json())
+);
+
+const fetchProject = async (slug, tag) => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/projects/${slug}.json`)
+    .then(resp => resp.json())
+);
+
+const fetchTopics = async tag => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/topics.json`)
+    .then(resp => resp.json())
+);
+
+const fetchTopic = async (slug, tag) => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/topics/${slug}.json`)
+    .then(resp => resp.json())
+);
+
+const fetchLearningObjectives = async tag => (
+  fetch(`${rawUrl}/${tag || await getLatestVersion()}/dist/learning-objectives.json`)
+    .then(resp => resp.json())
+);
+
+const filterByLocaleAndTrack = opts => arr => arr.filter((obj) => {
+  if (opts.locale && opts.locale !== obj.locale) {
+    return false;
+  }
+  if (opts.track && opts.track !== obj.track) {
+    return false;
+  }
+  return true;
+});
+
+export const createAPI = () => {
+  return {
+    projects: {
+      findMany: (opts = {}) => fetchProjects(opts.tag)
+        .then(filterByLocaleAndTrack(opts)),
+      findById: (slug, opts = {}) => fetchProject(slug, opts.tag),
+    },
+    topics: {
+      findMany: (opts = {}) => fetchTopics(opts.tag)
+        .then(filterByLocaleAndTrack(opts)),
+      findById: (slug, opts = {}) => fetchTopic(slug, opts.tag),
+    },
+    learningObjectives: {
+      findMany: (opts = {}) => fetchLearningObjectives(opts.tag),
+    },
+  };
+};

package/lib/model.js

@@ -1,13 +1,53 @@
 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 type = Array.isArray(attrSchema.type) ? attrSchema.type[0] : attrSchema.type;
-    const isRequired = !Array.isArray(attrSchema.type) || !attrSchema.type.includes('null');
+    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) {
@@ -63,43 +103,42 @@ const createBuildURL = collectionName => (id, q) => {
 };
 
 
-const createBuildQuery = defaultInclude => (q = {}) => ({
-  ...(!q.select && Object.keys(defaultInclude).length && { include: defaultInclude }),
-  ...q,
-});
-
-
-const buildDefaultInclude = schema => Object.keys(schema.properties || {}).reduce(
-  (memo, key) => (
-    (
-      schema.properties[key].$ref
-      || (
-        Array.isArray(schema.properties[key].anyOf)
-        && schema.properties[key].anyOf[0].$ref
-      )
-    )
-      ? { ...memo, [key]: true }
-      : memo
-  ),
-  {},
-);
+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;
+      }
+      if (isOptionalOneToOneRelation(schema, key) && data[key] === null) {
+        return memo;
+      }
+      return {
+        ...memo,
+        [key]: data[key],
+      };
+    },
+    {},
+  );
+};
 
 
-const createModel = (baseUrl, state, collectionName, schema = {}) => {
+export const createModel = (baseUrl, state, collectionName, schema = {}) => {
+  const primaryKey = schema.primaryKey || 'id';
   const validator = createValidator(schema);
   const buildURL = createBuildURL(collectionName);
-  const defaultInclude = buildDefaultInclude(schema);
-  const buildQuery = createBuildQuery(defaultInclude);
   const req = (...args) => createClient(baseUrl, state.authUser)(...args);
-  const create = q => req(buildURL(), {
+  const create = ({ data, ...q }) => req(buildURL(null, q), {
     method: 'POST',
-    body: buildQuery(q),
-  });
-
-  const put = q => req(buildURL(q.where.id), {
-    method: 'PUT',
-    body: buildQuery(q),
+    body: serializeData(data, schema),
   });
+  const put = ({ data, ...q }) => {
+    const { where, ...rest } = q;
+    return req(buildURL(where[primaryKey], rest), {
+      method: 'PUT',
+      body: serializeData(data, schema),
+    });
+  };
 
   const parse = data => {
     const parsed = Object.keys(data).reduce(
@@ -123,23 +162,53 @@ const createModel = (baseUrl, state, collectionName, schema = {}) => {
     );
   };
 
+  const relations = Object.keys(schema.properties || {}).reduce(
+    (memo, key) => (
+      isRequiredOneToOneRelation(schema, key)
+        ? Object.assign(memo, {
+          all: memo.all.concat(key),
+          oneToOne: memo.oneToOne.concat(key),
+          requiredOneToOne: memo.requiredOneToOne.concat(key),
+        })
+        : isOptionalOneToOneRelation(schema, key)
+          ? Object.assign(memo, {
+            all: memo.all.concat(key),
+            oneToOne: memo.oneToOne.concat(key),
+            optionalOneToOne: memo.optionalOneToOne.concat(key),
+          })
+          : isOneToManyRelation(schema, key)
+            ? Object.assign(memo, {
+              all: memo.all.concat(key),
+              oneToMany: memo.oneToMany.concat(key),
+            })
+            : memo
+    ),
+    {
+      all: [],
+      oneToOne: [],
+      requiredOneToOne: [],
+      optionalOneToOne: [],
+      oneToMany: [],
+    },
+  );
+
   return {
     get schema() {
-      return schema;
+      return { ...schema, primaryKey };
     },
-    get include() {
-      return defaultInclude;
+    get relations() {
+      return relations;
     },
     validateAttr: validator.validateAttr,
     validate: validator.validate,
-    findMany: q => req(buildURL(null, buildQuery(q)))
+    findMany: q => req(buildURL(null, q))
       .then(results => results.map(parse)),
-    findById: (id, q) => req(buildURL(id, buildQuery(q)))
+    findById: (id, q) => req(buildURL(id, q))
       .then(raw => !!raw ? parse(raw) : raw),
     create,
     update: put,
     upsert: opts => (
-      !opts.where.id
+      !opts.where[primaryKey]
         ? create({ data: opts.create })
         : put({ where: opts.where, data: opts.update })
     ),
@@ -147,9 +216,6 @@ const createModel = (baseUrl, state, collectionName, schema = {}) => {
   };
 };
 
-
-export default createModel;
-
 export const createModels = (url, state, schema) => {
   return Object.keys(schema.properties).reduce(
     (prev, key) => {

package/package.json

@@ -1,23 +1,33 @@
 {
   "name": "@laboratoria/sdk-js",
-  "version": "0.1.1",
+  "version": "1.2.0",
   "description": "Laboratoria JavaScript (browser) SDK",
   "scripts": {
-    "test": "jest --verbose --coverage"
+    "test": "jest --verbose --coverage",
+    "changelog": "git log $(git describe --tags --abbrev=0)..HEAD --oneline --format=\"* %h %s (%an)\""
   },
   "license": "MIT",
   "dependencies": {
-    "firebase": "^9.5.0"
+    "blueimp-md5": "^2.19.0",
+    "firebase": "^9.6.5"
   },
   "devDependencies": {
-    "@babel/core": "^7.16.0",
-    "@babel/plugin-transform-modules-commonjs": "^7.16.0",
-    "babel-jest": "^27.4.2",
-    "jest": "^27.4.3",
-    "webpack": "^5.64.4",
-    "webpack-cli": "^4.9.1"
+    "@babel/core": "^7.17.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.16.8",
+    "babel-jest": "^27.4.6",
+    "jest": "^27.4.7",
+    "webpack": "^5.68.0",
+    "webpack-cli": "^4.9.2"
   },
   "jest": {
-    "testEnvironment": "jsdom"
+    "testEnvironment": "jsdom",
+    "coverageThreshold": {
+      "global": {
+        "statements": 97,
+        "branches": 92,
+        "functions": 98,
+        "lines": 97
+      }
+    }
   }
-}
+}