@dnax/core 0.69.21 → 0.69.23

package/app/index.ts

@@ -44,10 +44,6 @@ async function runApp(config?: configRunApp, clb?: Function): Promise<Server> {
         }
 
         if (available) {
-          console.log("\n");
-          let spinner = ora("Initializing...").start();
-          spinner.color = "green";
-
           // Load all ressouce
           await init();
           const HonoApp = HonoInstance();
@@ -78,10 +74,8 @@ async function runApp(config?: configRunApp, clb?: Function): Promise<Server> {
             process.env.SERVER_NAME || Cfg?.server?.name || "SERVER";
 
           let envName = process.env?.NODE_ENV || "dev";
-          spinner.clear();
-          spinner.stop();
-          await sleep(250);
 
+          await sleep(150);
           let info = "";
 
           info += `${serverName}`.gray.underline.bold;

package/define/index.ts

@@ -13,6 +13,7 @@ import type {
   routeCtx,
   sessionCtx,
   Script,
+  TimeSeriesCollection,
 } from "../types";
 import { Cfg } from "../config/";
 import { deepMerge, freeze } from "../utils";
@@ -36,6 +37,18 @@ function Config(
   return config;
 }
 
+function TimeSeriesCollection(col: TimeSeriesCollection) {
+  col.timestamps = col?.timestamps ?? true;
+  if (!col?.timeseries?.granularity) {
+    col.timeseries.granularity = "seconds";
+  }
+  if (!col?.type) {
+    col.type = "timeseries";
+  }
+  if (!col?.fields) col.fields = [];
+  return col;
+}
+
 function Collection(col: Collection) {
   col.timestamps = col?.timestamps ?? true;
   if (!col?.fields) col.fields = [];

package/driver/mongo/connect.ts

@@ -21,7 +21,10 @@ async function connectToMongo(t: Tenant) {
         resolve(t);
       })
       .catch((error) => {
-        console.error(`Failed to connect Tenant ${t.id} : `, error?.message);
+        consola.error(
+          `Tenant: ${t.id} ,Database connection failed ❌`,
+          error?.message
+        );
         t.database.isConnected = false;
       });
 

package/driver/mongo/rest.ts

@@ -2454,7 +2454,7 @@ class useRest {
   watch(
     collection: string,
     pipeline: Array<any>,
-    options: ChangeStreamOptions
+    options?: ChangeStreamOptions
   ): ChangeStream {
     return this.#tenant.database.db?.collection(collection).watch(pipeline, {
       allowDiskUse: true,

package/lib/collection.ts

@@ -1,13 +1,14 @@
 import cleanDeep from "clean-deep";
 import { omit } from "radash";
 import { deepEqual } from "json-joy/lib/json-equal/deepEqual";
-import type { Collection, Field } from "./../types/index";
+import type { Collection, Field, TimeSeriesCollection } from "./../types/index";
 import { Glob } from "bun";
 import { Cfg } from "../config";
 import { useRest } from "../driver/mongo/rest";
 import { buildSchema } from "./schema";
 import { cleanPath, resolvePath } from "../utils";
 import { hookDatabase } from "../lib/database";
+type combinedCollection = Collection & TimeSeriesCollection;
 
 import path from "path";
 import consola from "consola";
@@ -68,63 +69,11 @@ async function syncCollectionDatabase() {
       //t.database.db.
 
       if (t.database.driver == "mongodb") {
-        const collections: Collection[] | undefined = Cfg.collections?.filter(
-          (cn) => cn.tenant_id == t.id
-        );
+        const collections: (Collection & TimeSeriesCollection[]) | undefined =
+          Cfg.collections?.filter((cn) => cn.tenant_id == t.id);
         if (collections?.length) {
           // searchEngine Section
-          if (t?.searchEngine?.meilisearch?.enabled) {
-            let allIndex_ = await t?.searchEngine?.meilisearch?.client
-              ?.getIndexes()
-              .then((e) => e.results)
-              .catch((err) => []);
 
-            for await (let c of collections) {
-              if (c?.searchEngine?.meilisearch?.index) {
-                if (c?.searchEngine?.meilisearch?.dispatchAction) {
-                  c.searchEngine.meilisearch.dispatchAction = "auto";
-                }
-
-                let indexExist = allIndex_?.find(
-                  (index) => index?.uid == c?.searchEngine?.meilisearch?.index
-                );
-                if (!indexExist) {
-                  await t.searchEngine.meilisearch.client
-                    ?.createIndex(c?.searchEngine?.meilisearch?.index, {
-                      primaryKey:
-                        c?.searchEngine?.meilisearch?.primaryKey || "_id",
-                    })
-                    .catch((err) => {
-                      //consola.error(err?.message);
-                    });
-                }
-
-                let attributes = await t?.searchEngine?.meilisearch?.client
-                  ?.index(c?.searchEngine?.meilisearch?.index)
-                  .getFilterableAttributes()
-                  .catch();
-
-                if (
-                  c?.searchEngine?.meilisearch?.filterableAttributes?.length
-                ) {
-                  let s = false;
-                  if (
-                    !deepEqual(
-                      attributes,
-                      c?.searchEngine?.meilisearch?.filterableAttributes
-                    )
-                  ) {
-                    await t?.searchEngine?.meilisearch?.client
-                      ?.index(c?.searchEngine?.meilisearch?.index)
-                      .updateFilterableAttributes(
-                        c?.searchEngine?.meilisearch?.filterableAttributes
-                      )
-                      .catch();
-                  }
-                }
-              }
-            }
-          }
           // DatabaseSection
           for await (let c of collections) {
             // boucle sur les collections
@@ -138,25 +87,23 @@ async function syncCollectionDatabase() {
               });
             }
 
-            if (c?.cache?.enabled && c?.cache?.init) {
-              c?.cache?.init({
-                rest: new useRest({
-                  tenant_id: t.id,
-                }),
-                state: c?.cache?.state || {},
-              });
-            }
-
             let collectionExist = collectionsInDatabase?.find(
               (col) => col?.name == c.slug
             );
 
             //console.log(c.slug, collectionExist);
 
-            if (!collectionExist) {
+            if (!collectionExist && c?.type != "timeseries") {
               await t.database.db?.createCollection(c.slug);
             }
 
+            if (!collectionExist && c?.type == "timeseries") {
+              await t.database.db?.createCollection(c.slug, {
+                timeseries: c?.timeseries,
+                expireAfterSeconds: c?.expireAfterSeconds,
+              });
+            }
+
             // suppression d'index
             c?.fields?.map((f) => {
               if (f?.unique === false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.69.21",
+  "version": "0.69.23",
   "module": "index.ts",
   "type": "module",
   "bin": {},

package/types/index.ts

@@ -423,6 +423,133 @@ export type Collection = {
   }; */
 };
 
+export type TimeSeriesCollection = {
+  type: "timeseries";
+  init?: (ctx: {
+    rest: InstanceType<typeof useRest>;
+    collection: string;
+  }) => void;
+  customApi?: {
+    aggregate?: (ctx: ctxApi) => Array<object> | null | undefined | typeof fn.error;
+    insertOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
+    insertMany?: (ctx: ctxApi) => Array<any> | null | undefined | typeof fn.error;
+    updateOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
+    updateMany?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
+    deleteOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
+    deleteMany?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
+    find?: (ctx: ctxApi) => Array<object> | null | undefined | typeof fn.error;
+    findWithMeta?: (ctx: ctxApi) => { meta: object; data: Array<object> } | null | undefined | typeof fn.error;
+    findOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
+    count?: (ctx: ctxApi) => number | null | undefined | typeof fn.error;
+  };
+
+  schema?: object;
+  auth?: {
+    enabled?: boolean;
+    handler?: (ctx: {
+      data: {
+        payload: any;
+      };
+      error: typeof fn.error;
+      c: Context;
+      rest: InstanceType<typeof useRest>;
+      session: sessionCtx;
+    }) => boolean | any;
+  };
+  middlewares?: Array<middlewareCtx>;
+  hooks?: {
+    beforeOperation?: hooksCtx;
+    beforeFind?: hooksCtx;
+    afterFind?: hooksCtx;
+    beforeUpdate?: hooksCtx;
+    afterUpdate?: hooksCtx;
+    beforeDelete?: hooksCtx;
+    afterDelete?: hooksCtx;
+    beforeInsert?: hooksCtx;
+    afterInsert?: hooksCtx;
+    beforeFindWithMeta?: hooksCtx;
+    afterFindWithMeta?: hooksCtx;
+    beforeAggregate?: hooksCtx;
+    afterAggregate?: hooksCtx;
+    beforeCount?: hooksCtx;
+    afterCount?: hooksCtx;
+    beforeUpload?: hooksCtx;
+    afterUpload?: hooksCtx;
+    beforeSearch?: hooksCtx;
+    afterSearch?: hooksCtx;
+    beforeListActivity?: hooksCtx;
+    afterListActivity?: hooksCtx;
+  };
+  access?: {
+    "*"?: accessCtx;
+    beforeAction?: accessCtx;
+    allAction?: accessCtx;
+    find?: accessCtx;
+    findOne?: accessCtx;
+    findOneAndUpdate?: accessCtx;
+    insertOne?: accessCtx;
+    insertMany?: accessCtx;
+    updateMany?: accessCtx;
+    updateOne?: accessCtx;
+    deleteOne?: accessCtx;
+    deleteMany?: accessCtx;
+    aggregate?: accessCtx;
+    upload?: accessCtx;
+    count?: accessCtx;
+    search?: accessCtx;
+    listActivity?: accessCtx;
+    findWithMeta?: accessCtx;
+  };
+  tenant_id?: string;
+  slug: string;
+  privateFields?: string[];
+  timestamps?: boolean;
+  description?: string;
+  timeseries:{
+    timeField:string;
+    metaField:string;
+    granularity:'seconds'|'minutes'|'hours';
+  };
+  fields?: Field[];
+  api?: {
+    //privateFields?: string[];
+    fields: {
+      readOnly?:string[];
+      select?:
+        | string[]
+        | ((ctx: {
+            action: Actions;
+            c: Context;
+            rest: InstanceType<typeof useRest>;
+            session: sessionCtx;
+          }) => string[]);
+      hidden?:
+        | string[]
+        | ((ctx: {
+            action: Actions;
+            c: Context;
+            rest: InstanceType<typeof useRest>;
+            session: sessionCtx;
+          }) => string[]);
+    };
+  };
+  allow?: ["dropCollection", "renameCollection"];
+  expireAfterSeconds?:number;
+  indexes?: Array<{
+    [key: string]: any;
+    unique?: Boolean;
+    expireAfterSeconds?: number;
+    partialFilterExpression?: any;
+  }>;
+  autoRemoveIndexes?: Array<{
+    [key: string]: any;
+  }>;
+  /* validate?:{
+    updateSchema?:AnySchema;
+  }; */
+};
+
+
 interface ApiError {
   code: number;
   message: string;