@cadenza.io/service 1.5.2 → 1.6.0

package/dist/index.js

@@ -2261,6 +2261,7 @@ var DatabaseController = class _DatabaseController {
               return true;
             } catch (error) {
               if (error.code === "42P04") {
+                console.log("Database already exists");
                 return true;
               }
               throw new Error(`Failed to create database: ${error.message}`);
@@ -2346,157 +2347,168 @@ var DatabaseController = class _DatabaseController {
             "Validates database schema structure and content"
           ).then(
             CadenzaService.createMetaTask(
-              "Split schema into tables",
-              this.splitTables.bind(this),
-              "Generates DDL for database schema"
+              "Sort tables by dependencies",
+              this.sortTablesByReferences.bind(this),
+              "Sorts tables by dependencies"
             ).then(
               CadenzaService.createMetaTask(
-                "Generate tasks",
-                (ctx) => {
-                  const { table, tableName, options } = ctx;
-                  this.createDatabaseTask(
-                    "query",
-                    tableName,
-                    table,
-                    this.queryFunction.bind(this),
-                    options
-                  );
-                  this.createDatabaseTask(
-                    "insert",
-                    tableName,
-                    table,
-                    this.insertFunction.bind(this),
-                    options
-                  );
-                  this.createDatabaseTask(
-                    "update",
-                    tableName,
-                    table,
-                    this.updateFunction.bind(this),
-                    options
-                  );
-                  this.createDatabaseTask(
-                    "delete",
-                    tableName,
-                    table,
-                    this.deleteFunction.bind(this),
-                    options
-                  );
-                },
-                "Generates auto-tasks for database schema"
-              ),
-              CadenzaService.createMetaTask("Generate DDL from table", (ctx) => {
-                var _a2;
-                const { ddl, table, tableName, schema, options } = ctx;
-                const fieldDefs = Object.entries(table.fields).map((value) => {
-                  var _a3, _b2, _c2, _d2, _e, _f, _g;
-                  const [fieldName, field] = value;
-                  let def = `${fieldName} ${field.type.toUpperCase()}`;
-                  if (field.type === "varchar")
-                    def += `(${(_b2 = (_a3 = field.constraints) == null ? void 0 : _a3.maxLength) != null ? _b2 : 255})`;
-                  if (field.type === "decimal")
-                    def += `(${(_d2 = (_c2 = field.constraints) == null ? void 0 : _c2.precision) != null ? _d2 : 10},${(_f = (_e = field.constraints) == null ? void 0 : _e.scale) != null ? _f : 2})`;
-                  if (field.primary) def += " PRIMARY KEY";
-                  if (field.unique) def += " UNIQUE";
-                  if (field.default !== void 0)
-                    def += ` DEFAULT ${field.default || "''"}`;
-                  if (field.required && !field.nullable) def += " NOT NULL";
-                  if (field.nullable) def += " NULL";
-                  if (field.generated)
-                    def += ` GENERATED ALWAYS AS ${field.generated.toUpperCase()} STORED`;
-                  if (field.references)
-                    def += ` REFERENCES ${field.references} ON DELETE ${field.onDelete || "NO_ACTION"}`;
-                  if (field.encrypted) def += " ENCRYPTED";
-                  if ((_g = field.constraints) == null ? void 0 : _g.check) {
-                    def += ` CHECK (${field.constraints.check})`;
-                  }
-                  return def;
-                }).join(", ");
-                let sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${fieldDefs})`;
-                if ((_a2 = table.meta) == null ? void 0 : _a2.appendOnly) {
-                  sql += `;
-CREATE TRIGGER prevent_modification BEFORE UPDATE OR DELETE ON ${tableName} FOR EACH STATEMENT EXECUTE FUNCTION prevent_context_modification();`;
-                }
-                ddl.push(sql);
-                return { ddl, table, tableName, schema, options };
-              }).then(
-                CadenzaService.createMetaTask("Generate index DDL", (ctx) => {
+                "Split schema into tables",
+                this.splitTables.bind(this),
+                "Generates DDL for database schema"
+              ).then(
+                CadenzaService.createMetaTask(
+                  "Generate tasks",
+                  (ctx) => {
+                    const { table, tableName, options } = ctx;
+                    this.createDatabaseTask(
+                      "query",
+                      tableName,
+                      table,
+                      this.queryFunction.bind(this),
+                      options
+                    );
+                    this.createDatabaseTask(
+                      "insert",
+                      tableName,
+                      table,
+                      this.insertFunction.bind(this),
+                      options
+                    );
+                    this.createDatabaseTask(
+                      "update",
+                      tableName,
+                      table,
+                      this.updateFunction.bind(this),
+                      options
+                    );
+                    this.createDatabaseTask(
+                      "delete",
+                      tableName,
+                      table,
+                      this.deleteFunction.bind(this),
+                      options
+                    );
+                  },
+                  "Generates auto-tasks for database schema"
+                ),
+                CadenzaService.createMetaTask("Generate DDL from table", (ctx) => {
+                  var _a2;
                   const { ddl, table, tableName, schema, options } = ctx;
-                  if (table.indexes) {
-                    table.indexes.forEach((fields) => {
-                      ddl.push(
-                        `CREATE INDEX idx_${tableName}_${fields.join("_")} ON ${tableName} (${fields.join(", ")});`
-                      );
-                    });
+                  const fieldDefs = Object.entries(table.fields).map((value) => {
+                    var _a3, _b2, _c2, _d2, _e, _f, _g;
+                    const [fieldName, field] = value;
+                    let def = `${fieldName} ${field.type.toUpperCase()}`;
+                    if (field.type === "varchar")
+                      def += `(${(_b2 = (_a3 = field.constraints) == null ? void 0 : _a3.maxLength) != null ? _b2 : 255})`;
+                    if (field.type === "decimal")
+                      def += `(${(_d2 = (_c2 = field.constraints) == null ? void 0 : _c2.precision) != null ? _d2 : 10},${(_f = (_e = field.constraints) == null ? void 0 : _e.scale) != null ? _f : 2})`;
+                    if (field.primary) def += " PRIMARY KEY";
+                    if (field.unique) def += " UNIQUE";
+                    if (field.default !== void 0)
+                      def += ` DEFAULT ${field.default || "''"}`;
+                    if (field.required && !field.nullable) def += " NOT NULL";
+                    if (field.nullable) def += " NULL";
+                    if (field.generated)
+                      def += ` GENERATED ALWAYS AS ${field.generated.toUpperCase()} STORED`;
+                    if (field.references)
+                      def += ` REFERENCES ${field.references} ON DELETE ${field.onDelete || "NO_ACTION"}`;
+                    if (field.encrypted) def += " ENCRYPTED";
+                    if ((_g = field.constraints) == null ? void 0 : _g.check) {
+                      def += ` CHECK (${field.constraints.check})`;
+                    }
+                    return def;
+                  }).join(", ");
+                  let sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${fieldDefs})`;
+                  if ((_a2 = table.meta) == null ? void 0 : _a2.appendOnly) {
+                    sql += `;
+CREATE TRIGGER prevent_modification BEFORE UPDATE OR DELETE ON ${tableName} FOR EACH STATEMENT EXECUTE FUNCTION prevent_context_modification();`;
                   }
+                  ddl.push(sql);
                   return { ddl, table, tableName, schema, options };
                 }).then(
-                  CadenzaService.createMetaTask("Generate unique index DDL", (ctx) => {
+                  CadenzaService.createMetaTask("Generate index DDL", (ctx) => {
                     const { ddl, table, tableName, schema, options } = ctx;
-                    if (table.uniqueConstraints) {
-                      table.uniqueConstraints.forEach((fields) => {
+                    if (table.indexes) {
+                      table.indexes.forEach((fields) => {
                         ddl.push(
-                          `ALTER TABLE ${tableName} ADD CONSTRAINT unique_${tableName}_${fields.join("_")} UNIQUE (${fields.join(", ")});`
+                          `CREATE INDEX idx_${tableName}_${fields.join("_")} ON ${tableName} (${fields.join(", ")});`
                         );
                       });
                     }
                     return { ddl, table, tableName, schema, options };
                   }).then(
-                    CadenzaService.createMetaTask("Generate trigger DDL", (ctx) => {
-                      const { ddl, table, tableName, schema, options } = ctx;
-                      if (table.triggers) {
-                        for (const [triggerName, trigger] of Object.entries(
-                          table.triggers
-                        )) {
-                          ddl.push(
-                            `CREATE TRIGGER ${triggerName} ${trigger.when} ${trigger.event} ON ${tableName} FOR EACH STATEMENT EXECUTE FUNCTION ${trigger.function};`
+                    CadenzaService.createMetaTask(
+                      "Generate unique index DDL",
+                      (ctx) => {
+                        const { ddl, table, tableName, schema, options } = ctx;
+                        if (table.uniqueConstraints) {
+                          table.uniqueConstraints.forEach(
+                            (fields) => {
+                              ddl.push(
+                                `ALTER TABLE ${tableName} ADD CONSTRAINT unique_${tableName}_${fields.join("_")} UNIQUE (${fields.join(", ")});`
+                              );
+                            }
                           );
                         }
+                        return { ddl, table, tableName, schema, options };
                       }
-                      return { ddl, table, tableName, schema, options };
-                    }).then(
-                      CadenzaService.createMetaTask(
-                        "Generate initial data DDL",
-                        (ctx) => {
-                          const { ddl, table, tableName, schema, options } = ctx;
-                          if (table.initialData) {
+                    ).then(
+                      CadenzaService.createMetaTask("Generate trigger DDL", (ctx) => {
+                        const { ddl, table, tableName, schema, options } = ctx;
+                        if (table.triggers) {
+                          for (const [triggerName, trigger] of Object.entries(
+                            table.triggers
+                          )) {
                             ddl.push(
-                              `INSERT INTO ${tableName} (${table.initialData.fields.join(", ")}) VALUES ${table.initialData.data.map(
-                                (row) => `(${row.map((value) => value === void 0 ? "NULL" : value).join(", ")})`
-                              ).join(", ")};`
+                              `CREATE TRIGGER ${triggerName} ${trigger.when} ${trigger.event} ON ${tableName} FOR EACH STATEMENT EXECUTE FUNCTION ${trigger.function};`
                             );
                           }
-                          return { ddl, table, tableName, schema, options };
                         }
-                      ).then(
-                        CadenzaService.createUniqueMetaTask("Join DDL", (ctx) => {
-                          const { joinedContexts } = ctx;
-                          const ddl = [];
-                          for (const joinedContext of joinedContexts) {
-                            ddl.push(...joinedContext.ddl);
+                        return { ddl, table, tableName, schema, options };
+                      }).then(
+                        CadenzaService.createMetaTask(
+                          "Generate initial data DDL",
+                          (ctx) => {
+                            const { ddl, table, tableName, schema, options } = ctx;
+                            if (table.initialData) {
+                              ddl.push(
+                                `INSERT INTO ${tableName} (${table.initialData.fields.join(", ")}) VALUES ${table.initialData.data.map(
+                                  (row) => `(${row.map((value) => value === void 0 ? "NULL" : value).join(", ")})`
+                                ).join(", ")};`
+                              );
+                            }
+                            return { ddl, table, tableName, schema, options };
                           }
-                          ddl.flat();
-                          return {
-                            ddl,
-                            schema: joinedContexts[0].schema,
-                            options: joinedContexts[0].options
-                          };
-                        }).then(
-                          CadenzaService.createMetaTask(
-                            "meta.applyDatabaseChanges",
-                            (ctx) => __async(this, null, function* () {
-                              const { ddl } = ctx;
-                              if (ddl && ddl.length > 0) {
-                                for (const sql of ddl) {
-                                  console.log("Applying SQL", sql);
-                                  yield this.dbClient.query(sql);
+                        ).then(
+                          CadenzaService.createUniqueMetaTask("Join DDL", (ctx) => {
+                            const { joinedContexts } = ctx;
+                            const ddl = [];
+                            for (const joinedContext of joinedContexts) {
+                              ddl.push(...joinedContext.ddl);
+                            }
+                            ddl.flat();
+                            return {
+                              ddl,
+                              schema: joinedContexts[0].schema,
+                              options: joinedContexts[0].options
+                            };
+                          }).then(
+                            CadenzaService.createMetaTask(
+                              "meta.applyDatabaseChanges",
+                              (ctx) => __async(this, null, function* () {
+                                const { ddl } = ctx;
+                                if (ddl && ddl.length > 0) {
+                                  for (const sql of ddl) {
+                                    console.log("Applying SQL", sql);
+                                    yield this.dbClient.query(sql);
+                                  }
                                 }
-                              }
-                              console.log("DDL applied");
-                              return ctx;
-                            }),
-                            "Applies generated DDL to the database"
-                          ).emits("meta.database.setup_done")
+                                console.log("DDL applied");
+                                return ctx;
+                              }),
+                              "Applies generated DDL to the database"
+                            ).emits("meta.database.setup_done")
+                          )
                         )
                       )
                     )
@@ -2559,10 +2571,51 @@ CREATE TRIGGER prevent_modification BEFORE UPDATE OR DELETE ON ${tableName} FOR
       throw new Error(`Timeout waiting for database to be ready`);
     });
   }
+  sortTablesByReferences(ctx) {
+    var _a2;
+    const schema = ctx.schema;
+    const graph = /* @__PURE__ */ new Map();
+    const allTables = Object.keys(schema.tables);
+    allTables.forEach((table) => graph.set(table, /* @__PURE__ */ new Set()));
+    for (const [tableName, table] of Object.entries(schema.tables)) {
+      for (const field of Object.values(table.fields)) {
+        if (field.references) {
+          const [refTable] = field.references.split(".");
+          if (allTables.includes(refTable)) {
+            (_a2 = graph.get(refTable)) == null ? void 0 : _a2.add(tableName);
+          }
+        }
+      }
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const tempMark = /* @__PURE__ */ new Set();
+    const sorted = [];
+    function visit(table) {
+      if (tempMark.has(table)) {
+        console.log("Circular reference detected involving table", table);
+        throw new Error(`Circular reference detected involving table ${table}`);
+      }
+      if (visited.has(table)) return;
+      tempMark.add(table);
+      for (const dep of graph.get(table) || []) {
+        visit(dep);
+      }
+      tempMark.delete(table);
+      visited.add(table);
+      sorted.push(table);
+    }
+    for (const table of allTables) {
+      if (!visited.has(table)) {
+        visit(table);
+      }
+    }
+    return __spreadProps(__spreadValues({}, ctx), { sortedTables: sorted });
+  }
   splitTables(ctx) {
     return __asyncGenerator(this, null, function* () {
-      const { schema, options = {} } = ctx;
-      for (const [tableName, table] of Object.entries(schema.tables)) {
+      const { sortedTables, schema, options = {} } = ctx;
+      for (const tableName of sortedTables) {
+        const table = schema.tables[tableName];
         yield { ddl: [], table, tableName, schema, options };
       }
     });