@lobb-js/core 0.13.0

package/src/database/DatabaseService.ts

@@ -0,0 +1,44 @@
+import type { DatabaseDriver } from "../types/index.ts";
+
+import { Lobb } from "../Lobb.ts";
+import { LobbError } from "../LobbError.ts";
+
+export class DatabaseService {
+  private dbDriver!: DatabaseDriver;
+
+  public static async init() {
+    const databaseService = new DatabaseService();
+    await databaseService.createConnection();
+    return databaseService;
+  }
+
+  public async close() {
+    await this.dbDriver.close();
+  }
+
+  public async createConnection() {
+    Lobb.instance.configManager.config.database.type =
+      Lobb.instance.configManager.config.database.type ?? "pg";
+
+    if (Lobb.instance.configManager.config.database.type === "pg") {
+      const DriverClass =
+        (await import("./drivers/pgDriver/PGDriver.ts")).PGDriver;
+      this.dbDriver = new DriverClass();
+    } else {
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message:
+          `driver of type (${Lobb.instance.configManager.config.database.type}) is not implemented`,
+      });
+    }
+    await this.dbDriver.createConnection();
+  }
+
+  public dropDatabase() {
+    return this.dbDriver.dropDatabase();
+  }
+
+  public getDriver() {
+    return this.dbDriver;
+  }
+}

package/src/database/DatabaseSyncManager.ts

@@ -0,0 +1,173 @@
+import * as _ from "lodash";
+
+import { diff } from "just-diff";
+import { runCoreDbSetup } from "../coreDbSetup/index.ts";
+import { MigrationsManager } from "./MigrationsManager.ts";
+import { LobbError } from "../LobbError.ts";
+import { Lobb } from "../Lobb.ts";
+import type { CollectionConfig, CollectionField, CollectionIndex } from "../types/index.ts";
+
+export class DatabaseSyncManager {
+  private dbDriver = Lobb.instance.databaseService.getDriver();
+  private config = Lobb.instance.configManager.config;
+
+  public static async init() {
+    const databaseSyncManager = new DatabaseSyncManager();
+    await databaseSyncManager.syncDatabase();
+    return databaseSyncManager;
+  }
+
+  public async syncDatabase(specificColleciton?: string) {
+    const forceSync = this.config.project.force_sync ?? false;
+
+    // Startup tasks run first — applies any idempotent DB fixes before schema reading begins.
+    await runCoreDbSetup();
+
+    const migrationsManager = new MigrationsManager();
+    await migrationsManager.init();
+
+    const dbSchemaDiff = await this.getDbDifferences(specificColleciton);
+    await this.applyDbSchemaDiff(dbSchemaDiff, forceSync);
+  }
+
+  private async applyDbSchemaDiff(
+    dbSchemaDiff: Array<{ op: string; path: (string | number)[]; value: unknown }>,
+    forceSync: boolean,
+  ) {
+    if (!dbSchemaDiff.length) return;
+
+    if (!forceSync) {
+      console.error(
+        "These are the differences between the config schema and the database schema",
+      );
+      console.error(
+        "You should add migrations to match the collection schema with the database schema",
+      );
+      console.error(dbSchemaDiff);
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message:
+          "The schema of the configuration collection does not align with the actual schema of the connected database.",
+      });
+    }
+
+    // just-diff may produce deep paths (length > 3) for sub-field changes within
+    // an existing index (e.g. renaming a column the index covers). Convert those
+    // into explicit drop+recreate (replace) ops, deduplicating by index name.
+    const syntheticReplaces = new Map<string, (string | number)[]>();
+    const normalizedDiff = dbSchemaDiff.filter((change) => {
+      if (change.path[1] === "indexes" && change.path.length > 3) {
+        const key = `${change.path[0]}:${change.path[2]}`;
+        if (!syntheticReplaces.has(key)) {
+          syntheticReplaces.set(key, [change.path[0], "indexes", change.path[2]]);
+        }
+        return false;
+      }
+      return true;
+    });
+    for (const path of syntheticReplaces.values()) {
+      normalizedDiff.push({ op: "replace", path, value: undefined });
+    }
+
+    // Apply changes in safe dependency order:
+    // 1. Drop collections, 2. Drop indexes, 3. Remove fields,
+    // 4. Add collections, 5. Add fields, 6. Add/replace indexes
+    const opOrder = (change: { op: string; path: (string | number)[] }) => {
+      if (change.path.length === 1 && change.op === "remove") return 0; // drop collection
+      if (change.path[1] === "indexes" && change.op === "remove") return 1; // drop index
+      if (change.path[1] === "indexes" && change.op === "replace") return 2; // replace index (drop+create)
+      if (change.path[1] === "fields" && change.op === "remove") return 3; // remove field
+      if (change.path.length === 1 && change.op === "add") return 4; // add collection
+      if (change.path[1] === "fields" && change.op === "add") return 5; // add field
+      if (change.path[1] === "indexes" && change.op === "add") return 6; // add index
+      return 7;
+    };
+    normalizedDiff.sort((a, b) => opOrder(a) - opOrder(b));
+
+    for (let index = 0; index < normalizedDiff.length; index++) {
+      const change = normalizedDiff[index];
+      if (change.path.length === 1 && change.op === "add") {
+        const addedCollectionName = change.path[0] as string;
+        await this.dbDriver.createCollection(
+          addedCollectionName,
+          change.value as CollectionConfig,
+        );
+      } else if (change.path.length === 1 && change.op === "remove") {
+        const removedCollectionName = change.path[0] as string;
+        await this.dbDriver.dropCollection(removedCollectionName);
+      } else if (
+        change.path.length === 3 &&
+        change.path[1] === "fields" &&
+        change.op === "add"
+      ) {
+        const collectionName = change.path[0] as string;
+        const fieldName = change.path[2] as string;
+        await this.dbDriver.addField(
+          collectionName,
+          fieldName,
+          change.value as CollectionField,
+        );
+      } else if (change.path[1] === "fields" && change.op === "remove") {
+        const collectionName = change.path[0] as string;
+        const fieldName = change.path[2] as string;
+        await this.dbDriver.removeField(collectionName, fieldName);
+      } else if (change.path[1] === "indexes" && change.op === "add") {
+        const collectionName = change.path[0] as string;
+        const indexName = change.path[2] as string;
+        await this.dbDriver.createIndex(
+          collectionName,
+          indexName,
+          change.value as CollectionIndex,
+        );
+      } else if (change.path[1] === "indexes" && change.op === "remove") {
+        const collectionName = change.path[0] as string;
+        const indexName = change.path[2] as string;
+        await this.dbDriver.dropIndex(collectionName, indexName);
+      } else if (change.path[1] === "indexes" && change.op === "replace") {
+        const collectionName = change.path[0] as string;
+        const indexName = change.path[2] as string;
+        const collectionConfig = Lobb.instance.configManager.getCollection(
+          collectionName,
+        );
+        const indexes = collectionConfig.indexes;
+        const index = indexes[indexName];
+        await this.dbDriver.dropIndex(collectionName, indexName);
+        await this.dbDriver.createIndex(
+          collectionName,
+          indexName,
+          index,
+        );
+      } else {
+        console.error(change);
+        throw new LobbError({
+          code: "INTERNAL_SERVER_ERROR",
+          message: "the database change above is not handled",
+        });
+      }
+    }
+  }
+
+  private async getDbDifferences(specificColleciton?: string) {
+    let dbSchema = await this.dbDriver.getDbSchema();
+    let configDbSchema = Lobb.instance.configManager.getDbSchema();
+
+    if (specificColleciton) {
+      if (dbSchema[specificColleciton]) {
+        dbSchema = {
+          [specificColleciton]: dbSchema[specificColleciton],
+        };
+      } else {
+        dbSchema = {};
+      }
+      if (configDbSchema[specificColleciton]) {
+        configDbSchema = {
+          [specificColleciton]: configDbSchema[specificColleciton],
+        };
+      } else {
+        configDbSchema = {};
+      }
+    }
+
+    return diff(dbSchema, configDbSchema);
+  }
+}

package/src/database/MigrationsManager.ts

@@ -0,0 +1,95 @@
+import type { Migration, MigrationProps, Migrations } from "../types/index.ts";
+
+import { coreMigrations } from "../coreMigrations/index.ts";
+import { LobbError } from "../LobbError.ts";
+import { Lobb } from "../Lobb.ts";
+
+export class MigrationsManager {
+  private dbDriver = Lobb.instance.databaseService.getDriver();
+
+  public async init() {
+    await this.handleMigrations();
+  }
+
+  private async handleMigrations(): Promise<void> {
+    const migrationOwners = [
+      ...Lobb.instance.configManager.getExtensionNames(),
+      "__core",
+      "__project",
+    ];
+
+    for (const migrationOwner of migrationOwners) {
+      const appliedNames = await this.getAppliedMigrationNamesByOwner(migrationOwner);
+      const migrations = await this.getMigrations(migrationOwner, appliedNames);
+      await this.applyMigrations(migrationOwner, migrations);
+    }
+  }
+
+  private async getAppliedMigrationNamesByOwner(owner: string): Promise<Set<string>> {
+    const result = await Lobb.instance.collectionService.findAll({
+      collectionName: "core_migrations",
+      params: { filter: { owner } },
+    });
+    return new Set(result.data.map((row) => row.migration_name as string));
+  }
+
+  private async getMigrations(
+    owner: string,
+    appliedNames: Set<string>,
+  ): Promise<Migrations> {
+    let allMigrations: Migrations = {};
+
+    if (owner === "__core") {
+      allMigrations = coreMigrations;
+    } else if (owner === "__project") {
+      allMigrations = Lobb.instance.configManager.config.migrations ?? {};
+    } else {
+      allMigrations = Lobb.instance.extensionSystem.getMigrations(owner);
+    }
+
+    return Object.fromEntries(
+      Object.entries(allMigrations).filter(([name]) => !appliedNames.has(name)),
+    );
+  }
+
+  private async applyMigrations(
+    migrationOwner: string,
+    migrations: Migrations,
+  ): Promise<void> {
+    for (const [migrationName, migration] of Object.entries(migrations)) {
+      let ownerForMessage: string;
+
+      if (migrationOwner === "__project") {
+        ownerForMessage = "CURRENT PROJECT";
+      } else if (migrationOwner === "__core") {
+        ownerForMessage = "LOBB CORE";
+      } else {
+        ownerForMessage = migrationOwner;
+      }
+
+      console.log(
+        `Executing the (${migrationName}) migration of (${ownerForMessage})`,
+      );
+      const migrationProps: MigrationProps = {
+        driver: Lobb.instance.databaseService.getDriver(),
+      };
+      try {
+        await (migration as Migration).up(migrationProps);
+      } catch (error) {
+        console.error(`(MIGRATIONS ERROR): ${error}`);
+        throw new LobbError({
+          code: "INTERNAL_SERVER_ERROR",
+          message:
+            `An Error happened trying to execute the (project) type at the (${migrationName}) migration`,
+        });
+      }
+      await Lobb.instance.collectionService.createOne({
+        collectionName: "core_migrations",
+        data: {
+          owner: migrationOwner,
+          migration_name: migrationName,
+        },
+      });
+    }
+  }
+}