@paralect/hive 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paralect/hive",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "",
   "main": "index.js",
   "bin": {

package/starter/src/app-config/index.js

@@ -8,6 +8,10 @@ dotenv.config({ path: `${__dirname}/.env.app` });
 console.log('process.env.HIVE_SRC', process.env.HIVE_SRC)
 
 if (process.env.HIVE_SRC) {
+  dotenv.config({
+    path: `${process.env.HIVE_SRC}/app-config/.env`,
+  });
+
   dotenv.config({
     path: `${process.env.HIVE_SRC}/app-config/.env.app`,
   });

package/starter/src/autoMap/addHandlers.js

@@ -2,14 +2,17 @@ import _ from "lodash";
 import db from "db";
 import ifUpdated from "helpers/db/ifUpdated";
 import schemaMappings from "./schemaMappings.js";
+import { ZodArray } from 'zod';
 
 const getDependentFields = (schema, dependentFieldName) => {
-  let targetSchema = schema[dependentFieldName];
-  if (targetSchema.type === "array") {
-    [targetSchema] = targetSchema.items;
+  let targetSchema = schema.shape[dependentFieldName];
+
+  if (targetSchema instanceof ZodArray) {
+    targetSchema = targetSchema.element;
   }
-  return Object.keys(targetSchema.keys).filter(
-    (key) => !_.includes(["_id", "createdOn", "updatedOn"], key)
+
+  return Object.keys(targetSchema.shape).filter(
+    (key) => !_.includes(['_id', 'createdOn', 'updatedOn'], key)
   );
 };
 
@@ -18,7 +21,7 @@ const updatedSchemaMappings = (() => {
   const schemaNames = Object.keys(schemaMappings);
   schemaNames.forEach((schemaName) => {
     const dependentFieldNames = Object.keys(schemaMappings[schemaName]);
-    const schema = db.schemas[schemaName].describe().keys;
+    const schema = db.schemas[schemaName];
     dependentFieldNames.forEach((dependentFieldName) => {
       const dependentFields = getDependentFields(schema, dependentFieldName);
       if (!_.isEmpty(dependentFields)) {
@@ -29,6 +32,7 @@ const updatedSchemaMappings = (() => {
         };
       }
     });
+
   });
   return result;
 })();
@@ -104,29 +108,29 @@ const addOnDependentEntitiesUpdatedHandlers = ({ schemaName }) => {
   dependentFieldNames.forEach((dependentFieldName) => {
     const dependentFieldSchemaName =
       schemaMappings[schemaName][dependentFieldName].schema;
-    const schema = db.schemas[schemaName].describe().keys;
+    const schema = db.schemas[schemaName];
     const dependentFields = getDependentFields(schema, dependentFieldName);
     db.services[dependentFieldSchemaName].on(
       "updated",
       ifUpdated(dependentFields, async ({ doc }) => {
         const toUpdate = _.pick(doc, ["_id", ...dependentFields]);
-        if (schema[dependentFieldName].type === "array") {
-          db.services[schemaName].atomic.update(
+        if (schema.shape[dependentFieldName] instanceof ZodArray) {
+          db.services[schemaName].atomic.updateOne(
             { [`${dependentFieldName}._id`]: doc._id },
             {
               $set: {
                 [`${dependentFieldName}.$`]: toUpdate,
               },
-            }
+            },
           );
         } else {
-          db.services[schemaName].atomic.update(
+          db.services[schemaName].atomic.updateOne(
             { [`${dependentFieldName}._id`]: doc._id },
             {
               $set: {
                 [`${dependentFieldName}`]: toUpdate,
               },
-            }
+            },
           );
         }
       })

package/starter/src/autoMap/mapSchema.js

@@ -5,20 +5,24 @@ import schemaMappings from "./schemaMappings.js";
 const schemaMappingService = db.services.schemaMappings;
 
 const getDependentFields = (schema, dependentFieldName) => {
-  let targetSchema = schema[dependentFieldName];
-  if (targetSchema.type === "array") {
-    targetSchema = targetSchema.items[0];
+  let targetSchema = schema.shape[dependentFieldName].shape;
+
+  if (targetSchema instanceof ZodArray) {
+    targetSchema = targetSchema.element;
   }
-  return Object.keys(targetSchema.keys).filter(
-    (key) => !_.includes(["_id", "createdOn", "updatedOn"], key)
+
+  return Object.keys(targetSchema).filter(
+    (key) => !_.includes(['_id', 'createdOn', 'updatedOn'], key)
   );
 };
-
-const joiSchemaToSchemaMappings = () => {
+const zodSchemaToSchemaMappings = () => {
   const newSchemaMappings = {};
+
   Object.keys(schemaMappings).forEach((schemaName) => {
-    const schema = db.schemas[schemaName].describe().keys;
+    const schema = db.schemas[schemaName];
+
     newSchemaMappings[schemaName] = {};
+
     Object.keys(schemaMappings[schemaName]).forEach((fieldName) => {
       newSchemaMappings[schemaName][fieldName] = {
         schema: schemaMappings[schemaName][fieldName].schema,
@@ -26,6 +30,7 @@ const joiSchemaToSchemaMappings = () => {
       };
     });
   });
+
   return newSchemaMappings;
 };
 
@@ -33,13 +38,14 @@ export default async () => {
   const prevSchema = await schemaMappingService.findOne({});
   const prevSchemaMappings = prevSchema?.mappings;
   if (!prevSchemaMappings) {
-    const initialSchemaMappings = joiSchemaToSchemaMappings();
+    const initialSchemaMappings = zodSchemaToSchemaMappings();
     schemaMappingService.create({ mappings: initialSchemaMappings });
   } else {
     const schemaNames = Object.keys(schemaMappings);
     await Promise.all(
       schemaNames.map(async (schemaName) => {
-        const schema = db.schemas[schemaName].describe().keys;
+        const schema = db.schemas[schemaName];
+
         const fieldNames = Object.keys(schemaMappings[schemaName]);
         await Promise.all(
           fieldNames.map(async (fieldName) => {
@@ -88,7 +94,7 @@ export default async () => {
     );
     schemaMappingService.atomic.update(
       { _id: prevSchema._id },
-      { $set: { mappings: joiSchemaToSchemaMappings() } }
+      { $set: { mappings: zodSchemaToSchemaMappings() } }
     );
   }
 };

package/starter/src/db.js

@@ -11,7 +11,6 @@ const db = connect(config.mongoUri);
 db.services = {};
 db.schemas = {};
 
-
 db.init = async () => {
   const schemaPaths = await getSchemas();
 
@@ -29,7 +28,9 @@ db.init = async () => {
       }
       db.schemas[schemaName] = schema;
       db.services[schemaName] = db.createService(`${resourceName}`, {
-        validate: (obj) => schema.validate(obj, { allowUnknown: true }),
+        validate: (obj) => { 
+          return { value: schema.passthrough().parse(obj) };
+        },
       });
 
     }

package/starter/src/helpers/schema/db.schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export default z
+  .object({
+    _id: z.string(),
+
+    createdOn: z.coerce.date(),
+    updatedOn: z.coerce.date(),
+  })
+  .strict();

package/starter/src/helpers/schema/pagination.schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const paginationSchema = z.object({
+  page: z.coerce.number().default(1),
+  perPage: z.coerce.number().default(10),
+
+  searchValue: z.string().optional(),
+
+  sort: z
+    .object({
+      createdOn: z.enum(['asc', 'desc']).default('asc'),
+    })
+    .default({}),
+});

package/starter/src/migrations/migrations-log/migration-log.schema.js

@@ -1,9 +1,7 @@
 import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
 
-const schema = z.object({
-  _id: z.string(),
-  createdOn: z.date(),
-  updatedOn: z.date(),
+export default dbSchema.extend({
   startTime: z.date(),
   finishTime: z.date().optional(),
   status: z.string(),
@@ -13,4 +11,3 @@ const schema = z.object({
   migrationVersion: z.number(),
 });
 
-export default schema;

package/starter/src/migrations/migrations.schema.js

@@ -1,10 +1,6 @@
 import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
 
-const schema = z.object({
-  _id: z.string(),
-  createdOn: z.date(),
-  updatedOn: z.date(),
+export default dbSchema.extend({
   version: z.number(),
 });
-
-export default schema;

package/starter/src/resources/schemaMappings/schemaMappings.schema.js

@@ -1,9 +1,6 @@
 import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
 
-export default z.object({
-  _id: z.string(),
-  createdOn: z.date(),
-  updatedOn: z.date(),
-
-  mappings: z.object(),
+export default dbSchema.extend({
+  mappings: z.object({}),
 });

package/starter/src/resources/tokens/tokens.schema.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
 
-export default z.object({
+export default dbSchema.extend({
   _id: z.string(),
   createdOn: z.date(),
   updatedOn: z.date(),

package/starter/src/resources/users/users.schema.js

@@ -1,10 +1,7 @@
 import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
 
-const users = z.object({
-  _id: z.string(),
-  createdOn: z.date(),
-  updatedOn: z.date(),
-
+const users = dbSchema.extend({
   email: z.string().email(),
   fullName: z.string(),
   avatarUrl: z.string().url().optional(),

package/starter/src/scheduler.js

@@ -1,21 +1,32 @@
+import path from 'path';
+import fs from 'fs';
 import moment from 'moment';
 import schedule from 'node-schedule';
 import requireDir from 'require-dir';
 
 export default () => {
-  requireDir(`${process.env.HIVE_SRC || "."}/scheduler/handlers`, {
-    mapValue: (handler, handlerName) => {
-      console.log(
-        `[scheduler] Registering handler ${handlerName} with cron ${handler.cron}`
-      );
+  const paths = [path.resolve(__dirname, './scheduler/handlers')];
+  if (process.env.HIVE_SRC) {
+    paths.push(path.resolve(process.env.HIVE_SRC, './scheduler/handlers'))
+  }
 
-      schedule.scheduleJob(handler.cron, () => {
-        console.log(
-          `[scheduler] ${moment().format()} executing ${handlerName} with cron ${handler.cron
-          }`
-        );
-        handler.handler();
+  paths.forEach((pathName) => {
+    if (fs.existsSync(pathName)) {
+      requireDir(pathName, {
+        mapValue: (handler, handlerName) => {
+          console.log(
+            `[scheduler] Registering handler ${handlerName} with cron ${handler.cron}`
+          );
+
+          schedule.scheduleJob(handler.cron, () => {
+            console.log(
+              `[scheduler] ${moment().format()} executing ${handlerName} with cron ${handler.cron
+              }`
+            );
+            handler.handler();
+          });
+        },
       });
-    },
+    }
   });
 }