feat(postgres): pubsub + queue services and migrate Store to current core API

packages/core/src/services/binary.spec.ts

@@ -52,28 +52,37 @@ abstract class BinaryTest<T extends BinaryService = BinaryService> extends Webda
    * @returns
    */
   tweakApp(app: TestApplication): Promise<void> {
-    app.addModel("ImageUser", ImageUser);
-    // Add the binaries relationship
-    app.getRelations("WebdaDemo/ImageUser").binaries = [
-      {
-        attribute: "images",
-        cardinality: "MANY"
+    // Register ImageUser with Relations.behaviors so that Binary/Binaries
+    // cardinality detection in uploadSuccess/deleteSuccess works correctly.
+    // (Previously used the now-removed app.getRelations() API.)
+    app.addModel("ImageUser", ImageUser, {
+      Identifier: "WebdaDemo/ImageUser",
+      Ancestors: [],
+      Subclasses: [],
+      Relations: {
+        behaviors: [
+          { attribute: "images", behavior: "Webda/BinariesImpl" },
+          { attribute: "profile", behavior: "Webda/Binary" }
+        ]
       },
-      {
-        attribute: "profile",
-        cardinality: "ONE"
-      }
-    ];
+      PrimaryKey: ["uuid"],
+      Events: [],
+      Schemas: {},
+      Actions: {},
+      Import: "",
+      Plural: "ImageUsers",
+      Reflection: {}
+    });
     return super.tweakApp(app);
   }
 
   getTestFile(): string {
     return process.cwd() + "/test/Dockerfile.txt";
   }
 
-  async beforeEach(init: boolean = true) {
+  async beforeEach() {
     this.cleanFiles.push("./downloadTo.tmp");
-    await super.beforeEach(init);
+    await super.beforeEach();
     this.binary = await this.getBinary();
     assert.notStrictEqual(this.binary, undefined);
     await this.binary.__clean();
@@ -156,7 +165,7 @@ abstract class BinaryTest<T extends BinaryService = BinaryService> extends Webda
     await user1.refresh();
     const ctx = await this.newContext();
     if (withLogin) {
-      ctx.getSession().login(user1.getUuid(), "fake");
+      ctx.getSession().login(user1.getUUID(), "fake");
     }
     return { binary, user1, ctx };
   }

packages/core/src/stores/store.spec.ts

@@ -26,13 +26,14 @@ export class PermissionModel extends CoreModel {
  * Use a custom model for the test
  */
 export class UserTest extends User {
-  uuid: string;
+  declare uuid: string;
   name: string;
   counter: number;
   idents: any[];
 }
 
 export class IdentTest extends Ident {
+  _lastUpdate: Date;
   counter: number;
   counter2: number;
   counter3: number;
@@ -88,7 +89,7 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
     };
   }
 
-  getModelClass(): ModelDefinition {
+  getModelClass(): any {
     return TestIdent;
   }
 
@@ -114,18 +115,7 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
   /**
    * Fill the Store with data to be queried
    */
-  async fillForQuery(): Promise<
-    ModelDefinition<
-      CoreModelAny<{
-        state: string;
-        team: {
-          id: number;
-        };
-        role: number;
-        order: number;
-      }>
-    >
-  > {
+  async fillForQuery(): Promise<any> {
     User.prototype.canAct = async () => true;
     //this.webda.getApplication().getModel("Webda/User").prototype.canAct = async () => true;
     //userStore._model.prototype.canAct = async () => true;
@@ -259,7 +249,7 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
 
   @test
   async collection() {
-    const Ident: ModelDefinition<CoreModelAny> = this.getModelClass();
+    const Ident = this.getModelClass();
     let ident = await Ident.create(<any>{
       test: "plop"
     });
@@ -357,12 +347,12 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
     const user3 = await UserTest.create({
       name: "test3"
     });
-    let users = await userStore.getAll();
+    let users = await (userStore as any).getAll();
     assert.strictEqual(users.length, 3);
     assert.strictEqual(users[0] instanceof userStore._model, true);
     assert.strictEqual(users[1] instanceof userStore._model, true);
     assert.strictEqual(users[2] instanceof userStore._model, true);
-    users = await userStore.getAll([user1.uuid, user3.uuid, randomUUID()]);
+    users = await (userStore as any).getAll([user1.uuid, user3.uuid, randomUUID()]);
     assert.strictEqual(users.length, 2);
     assert.strictEqual(users[0] instanceof userStore._model, true);
     assert.strictEqual(users[1] instanceof userStore._model, true);
@@ -432,21 +422,21 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
     this.log("DEBUG", "Retrieved object", object);
     assert.strictEqual(object.test, "plop2");
     assert.strictEqual(object.details.plop, "plop2");
-    getter = await identStore.get(object.uuid);
+    getter = await (identStore as any).get(object.uuid);
     assert.strictEqual(eventFired, 2);
     assert.strictEqual(getter.test, "plop2");
     await this.sleep(10);
     this.log("DEBUG", "Increment attribute");
     await IdentTest.ref(ident1.uuid).incrementAttribute("counter", 1);
-    let ident = await identStore.get(ident1.uuid);
+    let ident = await (identStore as any).get(ident1.uuid);
 
     // Verify lastUpdate is updated too
     this.assertLastUpdateNotEqual(ident._lastUpdate, ident1._lastUpdate, "lastUpdate after incrementAttribute failed");
     assert.strictEqual(ident.counter, 1);
     await IdentTest.ref(ident1.uuid).incrementAttribute("counter", 3);
-    ident1 = await identStore.get(ident1.uuid);
+    ident1 = await (identStore as any).get(ident1.uuid);
     assert.strictEqual(ident1.counter, 4);
-    await identStore.incrementAttributes(ident1.uuid, [
+    await (identStore as any).incrementAttributes(ident1.uuid, [
       { property: "counter", value: -6 },
       { property: "counter2", value: 10 }
     ]);
@@ -543,15 +533,15 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
     const store = this.userStore;
     let model = await UserTest.create({ counter: 1 });
     // Delete with condition
-    await assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), UpdateConditionFailError);
+    await assert.rejects(() => (store as any).delete(model.getUuid(), 4, "counter"), UpdateConditionFailError);
 
     await model.delete("counter", 1);
     // Test without condition
     model = await UserTest.create({ counter: 2 });
     await model.delete();
 
     // Deleting a non-existing object should be ignored
-    await store.delete(randomUUID());
+    await (store as any).delete(randomUUID());
   }
 
   async deleteConcurrent() {
@@ -611,7 +601,7 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
     await model.save();
     model.saveInnerMethod = true;
     await model.save();
-    await IdentTest.ref(model.getUuid()).setAttribute("_lastUpdate", new Date(100));
+    await (IdentTest.ref(model.getUuid()) as any).setAttribute("_lastUpdate", new Date(100));
     model.test = "yop";
     // Delete with condition
     await assert.rejects(() => model.save(), UpdateConditionFailError);
@@ -654,12 +644,12 @@ abstract class StoreTest<T extends Store<any>> extends WebdaApplicationTest {
 
   @test
   async upsert() {
-    const ref = IdentTest.ref(getUuid());
+    const ref = IdentTest.ref(randomUUID());
     if (await ref.exists()) {
       await ref.delete();
     }
-    await ref.upsert({ test: "true" });
-    await ref.upsert({ test: "false" });
+    await (ref as any).upsert({ test: "true" });
+    await (ref as any).upsert({ test: "false" });
   }
 }
 

packages/core/src/stores/store.ts

@@ -6,9 +6,10 @@ import { ServiceParameters } from "../services/serviceparameters.js";
 import { Service } from "../services/service.js";
 import * as WebdaQL from "@webda/ql";
 import type { WebdaQLString } from "@webda/ql";
-import { useApplication, useModelId } from "../application/hooks.js";
+import { useApplication, useModel, useModelId } from "../application/hooks.js";
 import { useLog } from "../loggers/hooks.js";
-import { useCore } from "../core/hooks.js";
+import { useCore, useModelMetadata } from "../core/hooks.js";
+import type { ModelMetadata } from "@webda/compiler";
 import { InstanceCache } from "../cache/cache.js";
 
 /** Error thrown when an item is not found in a store */
@@ -323,6 +324,10 @@ abstract class Store<K extends StoreParameters = StoreParameters, E extends Stor
    * Contains the current model
    */
   _model: ModelClass;
+  /**
+   * Contains the current model metadata
+   */
+  _modelMetadata: ModelMetadata;
   /**
    * Store the manager hierarchy with their depth
    */
@@ -331,6 +336,17 @@ abstract class Store<K extends StoreParameters = StoreParameters, E extends Stor
    * Contains the current model type
    */
   _modelType: string;
+
+  /**
+   * Override the resolved model class for this store at runtime. Used by
+   * the abstract `StoreTest` harness so test fixtures can substitute a
+   * subclass with extra fields in place of the configured model. In
+   * production this is a no-op the framework never calls.
+   * @param model - the substitute model class
+   */
+  setModelDefinitionHelper(model: ModelClass): void {
+    this._model = model;
+  }
   /**
    * Add metrics counter
    * ' UNION SELECT name, tbl_name as email, "" as col1, "" as col2, "" as col3, "" as col4, "" as col5, "" as col6, "" as col7, "" as col8 FROM sqlite_master --
@@ -342,8 +358,17 @@ abstract class Store<K extends StoreParameters = StoreParameters, E extends Stor
     queries: Histogram;
   };
 
-  /** Compute and register repositories for all known models based on available stores */
-  @InstanceCache()
+  /**
+   * Compute and register repositories for all known models based on available stores.
+   *
+   * Called from `Store.init()` so each store's init triggers a recompute.
+   * Cannot be cached: the FIRST store to init (typically `Registry`) would
+   * claim every model with its fallback repository, and subsequent
+   * stores wouldn't get a chance to claim their configured models.
+   * Re-running is idempotent — `registerRepository` overwrites map entries
+   * in place, and the resolution loop is deterministic per current
+   * service/model state.
+   */
   static computeStores() {
     // Gather all stores and register Repository
     const stores = Object.values(useCore().getServices()).filter(s => s instanceof Store);
@@ -378,54 +403,95 @@ abstract class Store<K extends StoreParameters = StoreParameters, E extends Stor
   }
 
   /**
-   * Retrieve the Model
+   * Retrieve the Model and build the models hierarchy map.
    *
-   * @throws Error if model is not found
+   * If the configured model cannot be found, or if no model was explicitly
+   * configured (store uses the default RegistryEntry fallback), the hierarchy
+   * stays empty and the store will not claim any model — preserving the
+   * pre-migration fallback behaviour for test-only or misconfigured stores.
    */
   computeParameters(): void {
-    /*
     super.computeParameters();
-    const app = useApplication();
-    this._model = useModel(this.parameters.model);
+
+    // Stores left with the default "Webda/RegistryEntry" model (and no
+    // additionalModels) should not participate in the hierarchy — they are
+    // typically the Registry fallback or test-only stores. Checking the
+    // resolved model directly avoids relying on a flag set by
+    // StoreParameters.load: addService bypasses subclass load() and
+    // constructs its parameters via the generic ServiceParameters.load,
+    // which never runs the StoreParameters override.
+    const isDefaultModel = !this.parameters.model || this.parameters.model === "Webda/RegistryEntry";
+    const hasAdditional = (this.parameters.additionalModels?.length ?? 0) > 0;
+    if (isDefaultModel && !hasAdditional) {
+      return;
+    }
+
+    // Guard: useModel throws on undefined and may return undefined/null for
+    // unknown models. Catch both so test-only or misconfigured stores stay
+    // harmless.
+    try {
+      this._model = useModel(this.parameters.model);
+    } catch {
+      this._model = undefined;
+    }
     if (!this._model) {
-      throw new Error(`Model not found: ${this.parameters.model}`);
+      useLog("TRACE", `Store ${this.getName?.() ?? "unknown"}: model not found: ${this.parameters.model}`);
+      return;
     }
     this._modelMetadata = useModelMetadata(this._model);
     if (!this._modelMetadata) {
-      throw new Error(`Model Metadata not found: ${this.parameters.model}`);
+      useLog("WARN", `Store ${this.getName?.() ?? "unknown"}: model metadata not found for ${this.parameters.model}`);
+      return;
     }
     useLog("TRACE", "METADATA", this._modelMetadata);
     this._modelType = this._modelMetadata.Identifier;
-    const recursive = (tree: ModelClass[], depth) => {
-      for (const model of tree) {
-        this._modelsHierarchy[this._modelMetadata.Identifier] ??= depth;
-        this._modelsHierarchy[this._modelMetadata.Identifier] = Math.min(
-          depth,
-          this._modelsHierarchy[this._modelMetadata.Identifier]
-        );
-        recursive(this._modelMetadata.Subclasses, depth + 1);
+
+    // Recursively populate _modelsHierarchy for a model's subclass tree.
+    // Each subclass identifier in meta.Subclasses is a string that we resolve
+    // via useModel. We keep the minimum depth seen for each identifier.
+    const recursive = (subclassIds: string[], depth: number) => {
+      for (const id of subclassIds) {
+        this._modelsHierarchy[id] = Math.min(depth, this._modelsHierarchy[id] ?? depth);
+        let subModel: ModelClass | undefined;
+        try {
+          subModel = useModel(id);
+        } catch {
+          continue;
+        }
+        if (!subModel) continue;
+        const subMeta = useModelMetadata(subModel);
+        if (!subMeta) continue;
+        recursive(subMeta.Subclasses ?? [], depth + 1);
       }
     };
-    // Compute the hierarchy
+
+    // Compute the hierarchy — reset first so re-resolve is idempotent
+    this._modelsHierarchy = {};
     this._modelsHierarchy[this._modelMetadata.Identifier] = 0;
-    // Strict Store only store their model
+    // Strict Store only stores their exact model
     if (!this.parameters.strict) {
-      recursive(this._modelMetadata.Subclasses, 1);
+      recursive(this._modelMetadata.Subclasses ?? [], 1);
     }
-    // Add additional models
-    if (this.parameters.additionalModels.length) {
-      // Strict mode is to only allow one model per store
+    // Add additional models (each treated as depth-0 roots with their own subtree)
+    if ((this.parameters.additionalModels ?? []).length) {
       if (this.parameters.strict) {
-        this.log("ERROR", "Cannot add additional models in strict mode");
+        useLog("ERROR", "Cannot add additional models in strict mode");
       } else {
-        for (const modelType of this.parameters.additionalModels) {
-          const model = useModel(modelType);
-          this._modelsHierarchy[this._modelMetadata.Identifier] = 0;
-          recursive(this._modelMetadata.Subclasses, 1);
+        for (const modelType of this.parameters.additionalModels!) {
+          let addModel: ModelClass | undefined;
+          try {
+            addModel = useModel(modelType);
+          } catch {
+            continue;
+          }
+          if (!addModel) continue;
+          const addMeta = useModelMetadata(addModel);
+          if (!addMeta) continue;
+          this._modelsHierarchy[addMeta.Identifier] = 0;
+          recursive(addMeta.Subclasses ?? [], 1);
         }
       }
     }
-    */
   }
 
   /**

packages/core/webda.module.json

@@ -3832,5 +3832,5 @@
     "rest-domain": "Webda/RESTOperationsTransport",
     "http-server": "Webda/HttpServer"
   },
-  "sourceDigest": "afd15f7002c79d9532e27b39040242e2"
+  "sourceDigest": "6d6c8cbfa29410b7b9d07a680a68daf2"
 }