@lobb-js/core 0.13.0

package/src/events/coreEvents/index.ts

@@ -0,0 +1,218 @@
+import type { Event } from "../EventSystem.ts";
+import { z } from "zod";
+
+export function getCoreEvents(): Event[] {
+  const events: Event[] = [];
+
+  events.push({
+    name: "core.init",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.webserver.middlwares.pre",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.webserver.middlwares.post",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  // service events
+  events.push({
+    name: "core.store.preFindAll",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.findAll",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.preFindOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.findOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.preCreateOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.createOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.preUpdateOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.updateOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.preDeleteOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.store.deleteOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.collection.transaction",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  // controller events
+  events.push({
+    name: "core.controllers.findAll",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.preFindAll",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.preFindOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.preCreateOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.createOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.findOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.preDeleteMany",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.preReadSingleton",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.preUpdateSingleton",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.findAll.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.findOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.createOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.updateOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.deleteOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.readSingleton.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.updateSingleton.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.deleteMany.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.updateMany.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.createMany.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.updateOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.deleteOne.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.findAll.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.deleteMany.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.updateMany.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.createMany.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.readSingleton.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.controllers.updateSingleton.override",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  return events;
+}

package/src/events/studioEvents/index.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import type { Event } from "../EventSystem.ts";
+
+export function getStudioEvents(): Event[] {
+  const events: Event[] = [];
+
+  events.push({
+    name: "studio.collections.preForeignKeySelect",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  events.push({
+    name: "studio.collections.preCreate",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  events.push({
+    name: "studio.collections.create",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  events.push({
+    name: "studio.collections.listView.tools",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  return events;
+}

package/src/extension/ExtensionSystem.ts

@@ -0,0 +1,236 @@
+import type { CollectionConfig } from "../types/index.ts";
+import type { Migrations } from "../types/index.ts";
+import type { Workflow } from "../workflows/WorkflowSystem.ts";
+
+import { Hono } from "hono";
+import { getDashboardRoute } from "./dashboardRoute.ts";
+import { LobbError } from "../LobbError.ts";
+import _ from "lodash";
+import { Lobb } from "../Lobb.ts";
+
+export class ExtensionSystem {
+  private collectionsOwners: Record<string, string> = {};
+
+  static init() {
+    const extensionSystem = new ExtensionSystem();
+    return extensionSystem;
+  }
+
+  public async executeExtensionsInitMethods() {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.init) {
+          await extension.init(Lobb.instance);
+        }
+      }
+    }
+  }
+
+  public async loadExtensionsCollections() {
+    const extensionCollections = await this.getExtensionCollections();
+    Lobb.instance.configManager.config.collections = {
+      ...Lobb.instance.configManager.config.collections,
+      ...extensionCollections,
+    };
+
+    const extensionsRelations = await this.getExtensionRelations();
+
+    if (typeof Lobb.instance.configManager.config.relations === "undefined") {
+      Lobb.instance.configManager.config.relations = [];
+    }
+
+    Lobb.instance.configManager.config.relations = [
+      ...Lobb.instance.configManager.config.relations,
+      ...extensionsRelations,
+    ];
+  }
+
+  private getExtensionRelations() {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    const relations = [];
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.relations) {
+          const extensionRelation = extension.relations(Lobb.instance);
+          if (extensionRelation) {
+            relations.push(...extensionRelation);
+          }
+        }
+      }
+    }
+    return relations;
+  }
+
+  public async executeExtensionsCloseMethods() {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.close) {
+          await extension.close(Lobb.instance);
+        }
+      }
+    }
+  }
+
+  public collectionMiddlewares(route: Hono) {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.collectionMiddlewares) {
+          route.use(...extension.collectionMiddlewares);
+        }
+      }
+    }
+  }
+
+  public async getExtensionMeta(extensionName: string) {
+    const extension = Lobb.instance.configManager.getExtension(extensionName);
+    if (extension) {
+      const extensionMeta = extension.meta
+        ? await extension.meta(Lobb.instance)
+        : {};
+      extensionMeta.version = extension.version;
+      return extensionMeta;
+    }
+  }
+
+  public getExtensionsOpenApiPaths() {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    let extensionPaths: Record<string, any> = {};
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.openapi) {
+          const extensionOpenapi = _.cloneDeep(extension.openapi);
+          extensionPaths = {
+            ...extensionPaths,
+            ...extensionOpenapi.paths,
+          };
+        }
+      }
+    }
+    return extensionPaths;
+  }
+
+  public getExtensionsOpenApiComponents() {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    let extensionComponents: Record<string, any> = {};
+
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.openapi) {
+          extensionComponents = {
+            ...extensionComponents,
+            ...extension.openapi.components,
+          };
+        }
+      }
+    }
+
+    return extensionComponents;
+  }
+
+  public async getExtensionCollections() {
+    const extensions = Lobb.instance.configManager.getExtensions();
+
+    let extensionCollections: Record<string, CollectionConfig> = {};
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.collections) {
+          const collections: Record<string, CollectionConfig> = await extension
+            .collections(Lobb.instance);
+
+          const collectionNames = Object.keys(collections);
+          for (let index = 0; index < collectionNames.length; index++) {
+            const collectionName = collectionNames[index];
+            this.collectionsOwners[collectionName] = extension.name;
+            if (!collectionName.startsWith(`${extension.name}_`)) {
+              throw new LobbError({
+                code: "INTERNAL_SERVER_ERROR",
+                message:
+                  `Collections from (${extension.name}) must be prefixed with (${extension.name}_) to avoid naming conflicts.`,
+              });
+            }
+          }
+
+          extensionCollections = {
+            ...extensionCollections,
+            ...collections,
+          };
+        }
+      }
+    }
+
+    return extensionCollections;
+  }
+
+  public routes() {
+    const extensionRoute = new Hono();
+    const extensions = Lobb.instance.configManager.getExtensions();
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        extensionRoute.route(
+          `/${extension.name}/dashboard`,
+          getDashboardRoute(extension.dashboard),
+        );
+        if (extension.routes) {
+          extensionRoute.route(`/${extension.name}`, extension.routes());
+        }
+      }
+    }
+    return extensionRoute;
+  }
+
+  public collectionRoutes(route: Hono) {
+    const extensions = Lobb.instance.configManager.getExtensions();
+    if (extensions) {
+      for (let index = 0; index < extensions.length; index++) {
+        const extension = extensions[index];
+        if (extension.collectionRoutes) {
+          extension.collectionRoutes(route);
+        }
+      }
+    }
+  }
+
+  public getCollectionOwner(collectionName: string) {
+    if (this.collectionsOwners[collectionName]) {
+      return this.collectionsOwners[collectionName];
+    }
+    return null;
+  }
+
+  public getMigrations(extensionName: string): Migrations {
+    const extension = Lobb.instance.configManager.getExtension(extensionName);
+    if (extension) {
+      return extension.migrations ?? {};
+    }
+
+    throw new LobbError({
+      code: "INTERNAL_SERVER_ERROR",
+      message:
+        "Couldn't find the extension in the (getMigrations) extensionSystem function",
+    });
+  }
+
+  public getWorkflows(extensionName: string): Workflow[] {
+    const extension = Lobb.instance.configManager.getExtension(extensionName);
+    if (extension) {
+      return extension.workflows ?? [];
+    }
+
+    throw new LobbError({
+      code: "INTERNAL_SERVER_ERROR",
+      message:
+        "Couldn't find the extension in the (getWorkflows) extensionSystem function",
+    });
+  }
+}

package/src/extension/dashboardRoute.ts

@@ -0,0 +1,35 @@
+import type { Context } from "hono";
+import type { Dashboard } from "../types/index.ts";
+
+import { Hono } from "hono";
+import { LobbError } from "../LobbError.ts";
+
+export function getDashboardRoute(dashboard?: Dashboard) {
+  const route = new Hono();
+
+  route.get(
+    "/",
+    (c: Context) => {
+      if (!dashboard) {
+        throw new LobbError({
+          code: "NOT_FOUND",
+          message: "This extension doesnt have a dashboard",
+        });
+      }
+
+      if (!dashboard.extension) {
+        throw new LobbError({
+          code: "NOT_FOUND",
+          message:
+            "The dashboard json of this extension doesnt have an extension property",
+        });
+      }
+
+      return c.body(dashboard.extension, 200, {
+        "Content-Type": "application/javascript",
+      });
+    },
+  );
+
+  return route;
+}

package/src/fields/ArrayField.ts

@@ -0,0 +1,33 @@
+// import { Field, type FieldOperatorsType } from "./Field.ts";
+
+// export class ArrayField extends Field {
+//   public static override type: string = "array";
+//   protected fieldName: string;
+//   protected collectionName: string;
+//   public fieldOperatorsType: FieldOperatorsType = "string";
+
+//   constructor(fieldName: string, collectionName: string) {
+//     super();
+//     this.fieldName = fieldName;
+//     this.collectionName = collectionName;
+//   }
+
+//   public override encodeFieldValue(value: any): any[] | null {
+//     if (value === null || value === undefined) {
+//       return null;
+//     }
+
+//     if (typeof value === "string") {
+//       try {
+//         value = JSON.parse(value);
+//       } catch (_error) {
+//         this.throwIncompatibleValueTypeError();
+//       }
+//     }
+
+//     if (!Array.isArray(value)) {
+//       this.throwIncompatibleValueTypeError();
+//     }
+//     return value;
+//   }
+// }

package/src/fields/BoolField.ts

@@ -0,0 +1,34 @@
+import { Field } from "../types/index.ts";
+
+export class BoolField extends Field {
+  public static override type: string = "bool";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+
+  public override encodeFieldValue(value: any): boolean | null {
+    if (value === null || value === undefined || value === "null") {
+      return null;
+    }
+
+    if (typeof value === "boolean") {
+      return value;
+    }
+
+    if (typeof value === "string") {
+      const lowerCaseValue = value.toLowerCase().trim();
+      if (lowerCaseValue === "true" || lowerCaseValue === "1") {
+        return true;
+      } else if (lowerCaseValue === "false" || lowerCaseValue === "0") {
+        return false;
+      }
+    }
+
+    this.throwIncompatibleValueTypeError();
+  }
+}

package/src/fields/DateField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class DateField extends Field {
+  public static override type: string = "date";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/DateTimeField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class DateTimeField extends Field {
+  public static override type: string = "datetime";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/DecimalField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class DecimalField extends Field {
+  public static override type: string = "decimal";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/FieldUtils.ts

@@ -0,0 +1,56 @@
+import type { Field } from "../types/index.ts";
+import { StringField } from "../fields/StringField.ts";
+import { TextField } from "../fields/TextField.ts";
+import { DateField } from "../fields/DateField.ts";
+import { LongField } from "../fields/LongField.ts";
+import { DecimalField } from "../fields/DecimalField.ts";
+import { FloatField } from "../fields/FloatField.ts";
+import { BoolField } from "../fields/BoolField.ts";
+import { IntegerField } from "../fields/IntegerField.ts";
+
+import { LobbError } from "../LobbError.ts";
+import { TimeField } from "./TimeField.ts";
+import { DateTimeField } from "./DateTimeField.ts";
+import { Lobb } from "../Lobb.ts";
+
+export class FieldUtils {
+  public static fieldClasses: any[] = [
+    StringField,
+    TextField,
+    LongField,
+    DecimalField,
+    FloatField,
+    BoolField,
+    IntegerField,
+    DateField,
+    TimeField,
+    DateTimeField,
+  ];
+
+  public static getFieldInstance(
+    fieldName: string,
+    collectionName: string,
+  ): Field {
+    const fieldConfig = Lobb.instance.configManager.getField(
+      fieldName,
+      collectionName,
+    );
+
+    for (let index = 0; index < this.fieldClasses.length; index++) {
+      const FieldClass = this.fieldClasses[index];
+      if (FieldClass.type === fieldConfig.type) {
+        return new FieldClass(fieldName, collectionName) as Field;
+      }
+    }
+
+    throw new LobbError({
+      code: "INTERNAL_SERVER_ERROR",
+      message:
+        `The ${fieldConfig.type} CollectionFieldType specified by the user doesnt exist`,
+    });
+  }
+
+  public static getFieldsTypes(): string[] {
+    return this.fieldClasses.map((Class) => Class.type);
+  }
+}

package/src/fields/FloatField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class FloatField extends Field {
+  public static override type: string = "float";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}