@dnax/core 0.2.4 → 0.2.6

package/app/hono.ts

@@ -126,6 +126,18 @@ function HonoInstance(): typeof app {
     let colAccess = col?.access?.hasOwnProperty(action) || null;
     let nextLifecyle: any = false;
 
+    // Middleware for apis
+    for await (let midd of col?.middlewares!) {
+      await midd({
+        token: c.var["token"] || null,
+        action: action,
+        c: c,
+        isAuth: c.var?._v?.isAuth || false,
+        rest: new useRest({ tenant_id: tenant_id }),
+        session: session as any,
+      });
+    }
+
     if (col && col?.access?.beforeAction) {
       await col?.access?.beforeAction({
         token: c.var["token"] || null,
@@ -217,6 +229,7 @@ function HonoInstance(): typeof app {
       if (action == "execService") {
         if (!service) return fn.error("Service not found", 404);
         response = await service.fx({
+          io: Cfg.io,
           data: body?.data || {},
           rest: rest,
           error: fn.error,
@@ -243,6 +256,7 @@ function HonoInstance(): typeof app {
       ) {
         if (action == "authCollection") {
           let reponse;
+
           if (!col?.auth?.enabled) fn.error("Auth not enabled", 401);
           if (!col?.auth?.handler) fn.error("Auth handler not set", 401);
           if (col?.auth?.handler) {

package/define/index.ts

@@ -1,4 +1,13 @@
-import type { Collection, Config, Endpoint, Service, Socket } from "../types";
+import type {
+  Collection,
+  Config,
+  Endpoint,
+  Service,
+  Socket,
+  cronConfig,
+  cronCtx,
+  middlewareCtx,
+} from "../types";
 import { Cfg } from "../config/";
 import { deepMerge, freeze } from "../utils";
 import { config } from "valibot";
@@ -23,6 +32,14 @@ function WebSocket(config: Socket) {
   return config;
 }
 
+function Middleware(ctx: middlewareCtx) {
+  return ctx;
+}
+
+function Task(config: cronConfig) {
+  return config;
+}
+
 const define = {
   Service,
   Config,
@@ -30,6 +47,9 @@ const define = {
   Endpoint,
   App: Config,
   WebSocket,
+  Middleware,
+  Task,
+  Cron: Task,
 };
 
 export default define;

package/driver/mongo/utils.ts

@@ -60,13 +60,13 @@ function buildPipeline(params: findParam, col?: Collection | undefined | null) {
         if (field) {
           pipeline.push({
             $lookup: {
-              from: field.relationTo,
+              from: field.relation?.to,
               localField: inc,
               foreignField: "_id",
               as: inc,
             },
           });
-          if (field.relationType == "ref-to-one") {
+          if (!field.relation?.hasMany) {
             pipeline.push({
               $unwind: {
                 path: `$${inc}`,
@@ -81,7 +81,7 @@ function buildPipeline(params: findParam, col?: Collection | undefined | null) {
         let field = getFieldCollection(inc?.localField, col);
         pipeline.push({
           $lookup: {
-            from: inc?.from || field?.relationTo,
+            from: inc?.from || field?.relation?.to,
             localField: inc?.localField || field?.name,
             foreignField: inc?.foreignField || "_id",
             as: inc?.as || inc?.localField || field?.name,
@@ -89,7 +89,7 @@ function buildPipeline(params: findParam, col?: Collection | undefined | null) {
           },
         });
 
-        if (field?.relationType == "ref-to-one") {
+        if (!field?.relation?.hasMany) {
           pipeline.push({
             $unwind: {
               path: `$${inc?.as || inc?.localField || field?.name}`,

package/lib/cron/index.ts

@@ -0,0 +1,49 @@
+import { Cron } from "croner";
+import { Glob } from "bun";
+import { Cfg } from "../../config";
+import path from "path";
+import type { cronConfig } from "../../types";
+import cleanDeep from "clean-deep";
+import { useRest } from "../../driver/mongo";
+async function initCron() {
+  let cronTasks = [];
+  if (Cfg?.tenants?.length) {
+    for await (let t of Cfg.tenants) {
+      let tenantPath = `${t.dir}/tasks/**/**.cron.{ts,js}`;
+      const glob = new Glob(tenantPath);
+      for await (let file of glob.scan({
+        cwd: Cfg.cwd,
+      })) {
+        let fullPathFile = path.join(Cfg.cwd || "", file);
+        await import(fullPathFile)
+          .then((inject) => {
+            let cronOpt = inject.default as cronConfig;
+            if (cronOpt?.enabled) {
+              let cronTask = new Cron(cronOpt.pattern, {
+                ...cleanDeep(cronOpt.options),
+              });
+              cronOpt.handler({
+                io: Cfg.io,
+                rest: new useRest({
+                  tenant_id: t.id,
+                }),
+                task: cronTask,
+              });
+              cronTasks.push({
+                tenant_id: t.id,
+                name: cronOpt.name,
+                cron: cronOpt,
+              });
+            }
+          })
+          .catch((err) => {
+            console.error(err);
+          });
+      }
+    }
+  }
+
+  //Cfg.endpoints = endpoints;
+}
+
+export { initCron };

package/lib/index.ts

@@ -2,6 +2,7 @@ import { loadAllCollections, syncCollectionDatabase } from "./collection";
 import { connectTenantsDatabase } from "../driver";
 import { loadEndpoints } from "./endpoint";
 import { loadServices } from "./service";
+import { initCron } from "./cron";
 import { loadSocket } from "./socket";
 // load all ressource
 async function init(cf = { app: null }) {
@@ -21,6 +22,8 @@ async function init(cf = { app: null }) {
 
   // load all loadEndpoints
   await loadEndpoints();
+
+  await initCron();
 }
 
 export { init };

package/lib/schema.ts

@@ -49,11 +49,11 @@ function buildSchema(col: Collection) {
       propertySchema[f.name] = v.string().email();
     }
 
-    if (f?.type == "relationship" && f.relationType == "ref-to-one") {
+    if (f?.type == "relationship") {
       propertySchema[f.name] = v.string().optional();
     }
 
-    if (f?.type == "relationship" && f.relationType == "ref-to-many") {
+    if (f?.type == "relationship" && f.relation?.hasMany) {
       propertySchema[f.name] = v.array().optional();
     }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dnax/core",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "module": "index.ts",
   "type": "module",
   "bin": {
-    "dnax": "./bin/index.ts"
+    "dnaxi": "./bin/index.ts"
   },
   "devDependencies": {
     "@types/bun": "latest",
@@ -20,12 +20,13 @@
     "@lukeed/ms": "^2.0.2",
     "@types/jsonwebtoken": "^9.0.6",
     "boxen": "^7.1.1",
+    "bree": "^9.2.4",
     "chokidar": "^3.6.0",
     "clean-deep": "^3.4.0",
     "collect.js": "^4.36.1",
     "consola": "^3.2.3",
     "cookie": "^0.6.0",
-    "croner": "^8.0.2",
+    "croner": "^8.1.1",
     "find-open-port": "^2.0.3",
     "generate-unique-id": "^2.0.3",
     "hono": "^4.4.3",

package/types/index.ts

@@ -1,4 +1,5 @@
 import type { AnySchema } from "joi";
+import { Cron } from "croner";
 import { updateParams } from "./../driver/mongo/@types";
 import * as v from "valibot";
 import type { Db, MongoClient } from "mongodb";
@@ -102,9 +103,12 @@ export type Field = {
   unique?: boolean;
   index?: boolean | "text" | "2dsphere";
   description?: string;
-
+  relation?: {
+    to: string; // collection name
+    hasMany?: boolean;
+  };
   sparse?: boolean;
-  relationType?: "ref-to-one" | "ref-to-many";
+  // relationType?: "ref-to-one" | "ref-to-many";
   /**
    * Overwrite custom validation schema
    * use {v} from "@dnax/core"} to build your own validation
@@ -116,6 +120,34 @@ export type Field = {
   relationTo?: string;
 };
 
+export type cronCtx = {
+  rest: InstanceType<typeof useRest>;
+  io: Io;
+  task: InstanceType<typeof Cron>;
+};
+
+export type cronConfig = {
+  name: string;
+  enabled?: boolean;
+  pattern: string;
+  options?: {
+    maxRuns?: Number;
+    startAt?: Date;
+    stopAt?: Date;
+    paused?: Boolean;
+  };
+  handler: (ctx: cronCtx) => void;
+};
+
+export type middlewareCtx = (ctx: {
+  token?: string;
+  action?: Actions;
+  c?: Context;
+  isAuth: boolean;
+  rest: InstanceType<typeof useRest>;
+  session: sessionCtx;
+}) => boolean | undefined | void | Promise<any>;
+
 export type accessCtx = (ctx: {
   token?: string;
   action?: Actions;
@@ -123,7 +155,7 @@ export type accessCtx = (ctx: {
   isAuth: boolean;
   rest: InstanceType<typeof useRest>;
   session: sessionCtx;
-}) => boolean | undefined | void;
+}) => boolean | undefined | void | Promise<any>;
 
 export type sessionCtx = {
   set: (session: { state: object | any; token?: string; _v?: object }) => void;
@@ -209,6 +241,7 @@ export type Collection = {
       session: sessionCtx;
     }) => boolean | any;
   };
+  middlewares?: Array<middlewareCtx>;
   hooks?: {
     beforeOperation?: hooksCtx;
     beforeFind?: hooksCtx;