@lobb-js/core 0.13.0

package/src/database/drivers/pgDriver/QueryBuilder.ts

@@ -0,0 +1,474 @@
+import type { FindAllParamsOutput } from "../../../types/index.ts";
+import { Lobb } from "../../../Lobb.ts";
+import format from "pg-format";
+import _ from "lodash";
+import { LobbError } from "../../../LobbError.ts";
+import { basicFilterOperatorsSchema } from "../../../types/index.ts";
+import { ZodError } from "zod";
+
+export class QueryBuilder {
+  collectionName: string;
+  params: FindAllParamsOutput;
+
+  static build(collectionName: string, params: FindAllParamsOutput) {
+    const builder = new QueryBuilder(collectionName, params);
+    return builder.build();
+  }
+
+  static buildTotalCountQuery(
+    collectionName: string,
+    params: FindAllParamsOutput,
+  ) {
+    const builder = new QueryBuilder(collectionName, params);
+    return builder.buildTotalCountQuery();
+  }
+
+  constructor(collectionName: string, params: FindAllParamsOutput) {
+    this.collectionName = collectionName;
+    this.params = params;
+  }
+
+  public build(): string {
+    const query = format(
+      `
+        SELECT %s
+        FROM %I
+        %s
+        %s
+        %s
+        %s
+        LIMIT %L
+        OFFSET %L
+      `,
+      this.getSelectFields(),
+      this.collectionName,
+      this.getJoins(),
+      this.getGroupBy(),
+      QueryBuilder.getWhere(this.params.filter, this.collectionName),
+      this.getSort(),
+      this.params.limit,
+      this.params.page
+        ? (this.params.page - 1) * this.params.limit
+        : this.params.offset,
+    );
+
+    return query;
+  }
+
+  public buildTotalCountQuery(): string {
+    const query = format(
+      `
+        SELECT COUNT(*)
+        FROM %I
+        %s
+        %s
+        %s
+      `,
+      this.collectionName,
+      this.getJoins(),
+      this.getGroupBy(),
+      QueryBuilder.getWhere(this.params.filter, this.collectionName),
+    );
+
+    return query;
+  }
+
+  private getSelectFields(): string {
+    // TODO: SANITIZE ALL THE FIELDS IN HERE THAT COMES FROM THE USER USING THE FORMAT LIBRARY
+    const columns: Set<string> = new Set([`${this.collectionName}.id`]);
+    const fields = this.params.fields.split(",").map((f) => f.trim());
+
+    // Separate main fields (no dot) from foreign fields
+    const mainFields = fields.filter((f) => !f.includes("."));
+    mainFields.forEach((field) => {
+      if (field === "*") {
+        const currentCollectionFields = Object.keys(
+          Lobb.instance.configManager.getCollection(this.collectionName).fields,
+        );
+        currentCollectionFields.forEach((item) => {
+          columns.add(`${this.collectionName}.${item}`);
+        });
+      } else {
+        columns.add(`${this.collectionName}.${field}`);
+      }
+    });
+
+    // Process foreign fields (nested relations)
+    if (fields.some((f) => f.includes("."))) {
+      const foreignFields: Record<string, string[]> = {};
+
+      // Group foreign fields by their parent
+      for (const field of fields) {
+        if (field.includes(".")) {
+          const foreignField = field.split(".")[0];
+          if (!foreignFields[foreignField]) foreignFields[foreignField] = [];
+        }
+      }
+
+      for (const foreignField of Object.keys(foreignFields)) {
+        foreignFields[foreignField] = fields
+          .filter((f) => f.startsWith(`${foreignField}.`))
+          .map((f) => f.slice(foreignField.length + 1));
+      }
+
+      // Add JSON build objects for each foreign field
+      for (
+        const [foreignField, nestedFields] of Object.entries(foreignFields)
+      ) {
+        const foreignFieldCollection = this.getForeignFieldCollection(
+          this.collectionName,
+          foreignField,
+        );
+
+        // Remove raw foreign key column
+        columns.delete(`${this.collectionName}.${foreignField}`);
+
+        // Determine alias (handle self-reference)
+        const alias = foreignFieldCollection === this.collectionName
+          ? `${foreignFieldCollection}_self_${foreignField}`
+          : foreignFieldCollection;
+
+        // Build JSON safely: only if related row exists
+        const jsonField = `
+          CASE
+            WHEN ${alias}.id IS NULL THEN NULL
+            ELSE json_build_object(
+              ${nestedFields.map((f) => `'${f}', ${alias}.${f}`).join(", ")}
+            )
+          END AS ${foreignField}
+        `;
+
+        columns.add(jsonField.trim());
+      }
+    }
+
+    return Array.from(columns).join(", ");
+  }
+
+  private getJsonBuildObject(
+    collectionName: string,
+    fieldName: string,
+    columns: string[],
+  ): string {
+    return `json_build_object(
+      ${
+      columns.map((column) => `'${column}', ${collectionName}.${column}`)
+        .join(",")
+    }
+    ) AS ${fieldName}`;
+  }
+
+  private getJoins(): string {
+    const joins: string[] = [];
+    const fields = this.params.fields.split(",").map((field) => field.trim());
+    const foreignFields: Set<string> = new Set();
+
+    // Collect all foreign fields from the selected fields
+    for (const field of fields) {
+      if (field.includes(".")) {
+        const foreignKeyField = field.split(".")[0];
+        foreignFields.add(foreignKeyField);
+      }
+    }
+
+    const collectionName = this.collectionName;
+
+    // Build LEFT JOIN statements
+    for (const foreignField of Array.from(foreignFields)) {
+      const foreignKeyCollection = this.getForeignFieldCollection(
+        collectionName,
+        foreignField,
+      );
+
+      // If self-referencing, generate a unique alias
+      const alias = foreignKeyCollection === collectionName
+        ? `${foreignKeyCollection}_self_${foreignField}`
+        : foreignKeyCollection;
+
+      joins.push(
+        `LEFT JOIN ${foreignKeyCollection} AS ${alias} ON ${alias}.id = ${collectionName}.${foreignField}`,
+      );
+    }
+
+    return joins.join(" ");
+  }
+
+  private getGroupBy(): string {
+    return "";
+  }
+
+  private getSort() {
+    if (!this.params.sort) return `ORDER BY ${this.collectionName}.id DESC`;
+
+    const orderByClauses = this.params.sort.split(",").map((field) => {
+      field = field.trim();
+      if (!field) return "";
+
+      const direction = field.startsWith("-") ? "DESC" : "ASC";
+      const fieldName = field.replace(/^-/, "");
+
+      return format(`${this.collectionName}.%I %s`, fieldName, direction);
+    }).filter(Boolean);
+
+    return orderByClauses.length ? `ORDER BY ${orderByClauses.join(", ")}` : "";
+  }
+
+  public static getWhere(filterObject: any, collection: string): string {
+    const filter = _.cloneDeepWith(
+      filterObject,
+      (value: any, key: any) => {
+        if (typeof key === "string" && !key.includes("$")) {
+          // transform `{ title: "test" }` to `{ title: $eq: "test" }`
+          if (!_.isPlainObject(value)) {
+            value = {
+              $eq: value,
+            };
+          }
+
+          // validate the schema of the filterComparisonOperators object
+          try {
+            value = basicFilterOperatorsSchema.parse(value);
+          } catch (error) {
+            if (error instanceof ZodError) {
+              throw new LobbError({
+                code: "BAD_REQUEST",
+                message: "Invalid filter schema",
+                details: error.errors[0],
+              });
+            }
+            throw error;
+          }
+
+          return value;
+        }
+      },
+    );
+
+    const whereClause = this.buildWhereClause(filter, collection);
+
+    return whereClause ? `WHERE ${whereClause}` : "";
+  }
+
+  public static buildWhereClause(
+    filterObject: any,
+    collection: string,
+  ): string {
+    function columnHandler(collectionName: string, fieldName: string) {
+      return `${collectionName}.${format.ident(fieldName)}`;
+    }
+
+    if (!filterObject) {
+      return "";
+    }
+
+    const operatorsMap: { [key: string]: string } = {
+      "$eq": "=",
+      "$ne": "<>",
+      "$in": "IN",
+      "$nin": "NOT IN",
+      "$lt": "<",
+      "$lte": "<=",
+      "$gt": ">",
+      "$gte": ">=",
+      "$between": "BETWEEN",
+      "$nbetween": "NOT BETWEEN",
+    };
+
+    let whereClause = "";
+
+    // Function to process each individual condition
+    const processCondition = (key: string, value: any): string => {
+      if (value && typeof value === "object") {
+        const operator = Object.keys(value)[0];
+
+        if (operator) {
+          if (operatorsMap[operator]) {
+            const sqlOperator = operatorsMap[operator];
+            const conditionValue = value[operator];
+
+            if (Array.isArray(conditionValue)) {
+              if (sqlOperator === "IN" || sqlOperator === "NOT IN") {
+                const placeholders = conditionValue.map((val) =>
+                  format("%L", val)
+                )
+                  .join(", ");
+                return `${
+                  columnHandler(collection, key)
+                } ${sqlOperator} (${placeholders})`;
+              }
+              if (sqlOperator === "BETWEEN" || sqlOperator === "NOT BETWEEN") {
+                return `${columnHandler(collection, key)} ${sqlOperator} ${
+                  format("%L", conditionValue[0])
+                } AND ${format("%L", conditionValue[1])}`;
+              }
+            }
+
+            if (conditionValue === null) {
+              if (operator === "$eq") {
+                return `${columnHandler(collection, key)} IS NULL`;
+              } else if (operator === "$ne") {
+                return `${columnHandler(collection, key)} IS NOT NULL`;
+              }
+            }
+
+            // TODO: add the collection identifier to all other conditions so that the select records from boms work in products
+            return `${columnHandler(collection, key)} ${sqlOperator} ${
+              format("%L", conditionValue)
+            }`;
+          } else if (operator === "$contains") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } LIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$icontains") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } ILIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$ncontains") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } NOT LIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$incontains") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } NOT ILIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$starts_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } LIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$istarts_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } ILIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$nstarts_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } NOT LIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$instarts_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `${conditionValue}%`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } NOT ILIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$ends_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } LIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$iends_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } ILIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$nends_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } NOT LIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$inends_with") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", `%${conditionValue}`);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } NOT ILIKE ${formattedValue}`;
+            return subQuery;
+          } else if (operator === "$regex") {
+            const conditionValue = value[operator];
+            const formattedValue = format("%L", conditionValue);
+            const subQuery = `${
+              columnHandler(collection, key)
+            } ~ ${formattedValue}`;
+            return subQuery;
+          } else {
+            throw new LobbError({
+              code: "INTERNAL_SERVER_ERROR",
+              message: `The (${operator}) operator is not supported`,
+            });
+          }
+        }
+
+        const sql = this.buildWhereClause(value, collection);
+        return sql ? `(${sql})` : "";
+      }
+
+      return `${columnHandler(collection, key)} = ${format("%L", value)}`;
+    };
+
+    if (filterObject.$and) {
+      const andConditions = filterObject.$and.map((condition: any) => {
+        const sql = this.buildWhereClause(condition, collection);
+        return sql ? `(${sql})` : "";
+      }).filter(Boolean).join(" AND ");
+      whereClause += andConditions;
+    } else if (filterObject.$or) {
+      const orConditions = filterObject.$or.map((condition: any) => {
+        const sql = this.buildWhereClause(condition, collection);
+        return sql ? `(${sql})` : "";
+      }).filter(Boolean).join(" OR ");
+      whereClause += orConditions;
+    } else {
+      Object.keys(filterObject).forEach((key) => {
+        if (key !== "$and" && key !== "$or") {
+          const condition = processCondition(key, filterObject[key]);
+          if (condition) {
+            whereClause += ` ${condition} AND`;
+          }
+        }
+      });
+      whereClause = whereClause.replace(/ AND$/, "");
+    }
+
+    return whereClause.trim();
+  }
+
+  getForeignFieldCollection(collection: string, foreignField: string) {
+    const relations = Lobb.instance.configManager.config.relations;
+    if (!relations) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `Can't use dot (".") operator in (fields) findAll property because there is not relations`,
+      });
+    }
+    const foreignFieldRelation = relations.find((relation) =>
+      relation.from.collection === collection &&
+      relation.from.field === foreignField
+    );
+    if (!foreignFieldRelation) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `Couldn't find the relation object of the (${this.collectionName}.${foreignField}) field`,
+      });
+    }
+
+    return foreignFieldRelation.to.collection;
+  }
+}

package/src/database/drivers/pgDriver/utils.ts

@@ -0,0 +1,6 @@
+export function fieldsHasId(findAllFields: string): boolean {
+  return findAllFields
+    .split(",")
+    .map((f) => f.trim())
+    .some((f) => f === "id" || f === "*");
+}

package/src/events/EventSystem.ts

@@ -0,0 +1,191 @@
+import type { ZodObject } from "zod";
+import { Lobb } from "../Lobb.ts";
+import { getCoreEvents } from "./coreEvents/index.ts";
+import { LobbError } from "../LobbError.ts";
+import { isValidCron } from "cron-validator";
+import { CronJob } from "cron";
+import { LobbReturnError } from "../api/errorHandler.ts";
+import { getStudioEvents } from "./studioEvents/index.ts";
+
+// Event type
+export interface Event {
+  name: string;
+  inputSchema: ZodObject<any>;
+  outputSchema: ZodObject<any>;
+}
+
+// Subscription type
+type AnyFunction = (...args: any[]) => any;
+export interface EventContext {
+  eventName: string;
+  workflows: Record<string, AnyFunction>;
+  LobbError: typeof LobbError;
+  lobb: Lobb;
+}
+type Handler = (input: any, ctx: EventContext) => Promise<any>;
+export interface Subscription {
+  name: string;
+  eventName: string;
+  handler: Handler;
+}
+
+export class EventSystem {
+  public events: Event[] = [];
+  private subscriptions: Subscription[] = [];
+  private crons: Record<string, CronJob> = {};
+
+  public async init() {
+    this.registerCoreEvents();
+    this.registerStudioEvents();
+  }
+
+  public getEvent(eventName: string): Event {
+    const event = this.events.find((event) => event.name === eventName);
+    if (!event) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `An event with the (${eventName}) name doesnt exist`,
+      });
+    }
+    return event;
+  }
+
+  public register(event: Event) {
+    this.events.push(event);
+  }
+
+  public subscribe(subscription: Subscription) {
+    if (this.subscriptionExist(subscription.name)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `The subscription with the (${subscription.name}) name already exists`,
+      });
+    }
+    if (isValidCron(subscription.eventName)) {
+      const eventContext = this.getEventContext(subscription.eventName);
+      const job = CronJob.from({
+        cronTime: subscription.eventName,
+        onTick: async function () {
+          try {
+            await subscription.handler({}, eventContext);
+          } catch (error) {
+            console.error("CRON WORKFLOW ERROR:");
+            console.error(error);
+          }
+        },
+        start: true,
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      });
+      this.crons[subscription.name] = job;
+    } else {
+      if (!this.eventExists(subscription.eventName)) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message:
+            `Trying to subscribe to the (${subscription.eventName}) event that doesnt exist`,
+        });
+      }
+      this.subscriptions.push(subscription);
+    }
+  }
+
+  public async unsubscribe(subscriptionName: string) {
+    this.subscriptions = this.subscriptions.filter(
+      (sub) => sub.name !== subscriptionName,
+    );
+    if (this.crons[subscriptionName]) {
+      await this.crons[subscriptionName].stop();
+      delete this.crons[subscriptionName];
+    }
+  }
+
+  public subscriptionExist(subscriptionName: string) {
+    return this.subscriptions.some(
+      (subscription) => subscription.name === subscriptionName,
+    );
+  }
+
+  public async emit(eventName: string, input: Record<string, any>) {
+    if (!this.eventExists(eventName)) {
+      throw new Error(
+        `Trying to emit with the (${eventName}) event that doesnt exist`,
+      );
+    }
+
+    const subscriptions = this.subscriptions.filter((subscription) => {
+      return eventName.startsWith(subscription.eventName);
+    });
+
+    if (!subscriptions.length) {
+      return input;
+    }
+
+    let output;
+    for (let index = 0; index < subscriptions.length; index++) {
+      const subscription = subscriptions[index];
+      try {
+        const localOutput = await subscription.handler(
+          input,
+          this.getEventContext(subscription.eventName),
+        );
+
+        output = localOutput;
+      } catch (error) {
+        if (error instanceof Response) {
+          throw new LobbReturnError(error);
+        }
+
+        throw error;
+      }
+    }
+
+    return output;
+  }
+
+  public getEventContext(eventName: string): EventContext {
+    return {
+      eventName: eventName,
+      workflows: Object.fromEntries(
+        Lobb.instance.workflowSystem.workflows.map((wf) => [
+          wf.name,
+          wf.handler,
+        ]),
+      ),
+      LobbError: LobbError,
+      lobb: Lobb.instance,
+    };
+  }
+
+  public eventHasSubscribers(eventName: string) {
+    const subscriptions = this.subscriptions.filter((subscription) => {
+      return eventName.startsWith(subscription.eventName);
+    });
+    return Boolean(subscriptions.length);
+  }
+
+  public eventExists(eventName: string) {
+    return this.events.some((event) => event.name === eventName);
+  }
+
+  public close() {
+    this.events = [];
+    this.subscriptions = [];
+  }
+
+  public registerCoreEvents() {
+    const coreEvents = getCoreEvents();
+    for (let index = 0; index < coreEvents.length; index++) {
+      const coreEvent = coreEvents[index];
+      this.register(coreEvent);
+    }
+  }
+
+  public registerStudioEvents() {
+    const coreEvents = getStudioEvents();
+    for (let index = 0; index < coreEvents.length; index++) {
+      const coreEvent = coreEvents[index];
+      this.register(coreEvent);
+    }
+  }
+}