feat: modules and resources domains, drop removed domains, regenerated models

src/domains/CatalogDomain.ts

@@ -1,22 +1,22 @@
 import { SyncedState } from '../state/SyncedState.js';
 import type { RudderContext } from '../core/context.js';
 import { api } from '../generated/api.js';
-import type { CatalogItem } from '../generated/catalog.js';
+import type { CatalogCurrency } from '../generated/catalog.js';
 
 /**
- * CatalogDomain — the item catalog, keyed by slug. Synced under revision
- * key `catalog`. Feeds the merged {@link InventoryDomain} view.
+ * CatalogDomain — currency definitions, keyed by slug. Synced under revision
+ * key `catalog`.
  */
-export class CatalogDomain extends SyncedState<Map<string, CatalogItem>> {
+export class CatalogDomain extends SyncedState<Map<string, CatalogCurrency>> {
   readonly syncKey = 'catalog';
 
   constructor(ctx: RudderContext) {
     super(async () => {
-      const response = await api.listCatalogItems(ctx);
-      const map = new Map<string, CatalogItem>();
-      for (const item of response.items ?? []) {
-        if (!item.slug) continue;
-        map.set(item.slug, item);
+      const response = await api.listCatalogCurrencies(ctx);
+      const map = new Map<string, CatalogCurrency>();
+      for (const currency of response.currencies ?? []) {
+        if (!currency.slug) continue;
+        map.set(currency.slug, currency);
       }
       return map;
     });

src/domains/ConfigDomain.ts

@@ -1,33 +0,0 @@
-import { RemoteConfigState, type RemoteConfigShape } from '../state/RemoteConfigState.js';
-import type { RudderContext } from '../core/context.js';
-import { api } from '../generated/api.js';
-import type { RemoteConfig } from '../generated/remote-config.js';
-
-/**
- * ConfigDomain — typed remote configuration as an observable entity. Synced
- * under revision key `config`. Extends {@link RemoteConfigState}, which adds
- * typed `get()` and scenario override support.
- */
-export class ConfigDomain<
-  TConfig extends RemoteConfigShape = RemoteConfigShape,
-> extends RemoteConfigState<TConfig> {
-  readonly syncKey = 'config';
-
-  constructor(ctx: RudderContext) {
-    super(async () => {
-      const response = await api.listSdkRemoteConfigs(ctx);
-      const map = new Map<string, RemoteConfig>();
-      if (response.configs) {
-        for (const [key, config] of Object.entries(response.configs)) {
-          // The server already filters inactive configs out (the game cache skips
-          // !active) and may omit `active` on the wire, so keep anything that is
-          // not explicitly inactive instead of dropping configs that carry no flag.
-          if (config && config.active !== false) {
-            map.set(config.key ?? key, config);
-          }
-        }
-      }
-      return map;
-    });
-  }
-}

src/domains/InventoryDomain.ts

@@ -1,31 +0,0 @@
-import { SyncedState } from '../state/SyncedState.js';
-import type { RudderContext } from '../core/context.js';
-import { api } from '../generated/api.js';
-import { mergeInventory, type InventoryItem } from '../state/inventory.js';
-import type { CatalogDomain } from './CatalogDomain.js';
-
-/**
- * InventoryDomain — owned items merged with their catalog entries. Synced
- * under revision key `inventory`; also refreshes when the catalog changes.
- */
-export class InventoryDomain extends SyncedState<InventoryItem[]> {
-  readonly syncKey = 'inventory';
-
-  constructor(ctx: RudderContext, catalog: CatalogDomain) {
-    super(async () => {
-      const [response, catalogItems] = await Promise.all([
-        api.getInventory(ctx),
-        catalog.load(),
-      ]);
-      return mergeInventory(response.items ?? [], catalogItems);
-    });
-
-    // Catalog changes flow into the merged inventory view.
-    let previousCatalog = catalog.data;
-    catalog.onChange((snapshot) => {
-      if (snapshot.data === previousCatalog) return;
-      previousCatalog = snapshot.data;
-      this.invalidate();
-    });
-  }
-}

src/domains/ModulesDomain.ts

@@ -0,0 +1,11 @@
+import type { RudderContext } from '../core/context.js';
+import { api } from '../generated/api.js';
+import type { CallModuleFunctionClientResponse } from '../generated/modules.js';
+
+export class ModulesDomain {
+  constructor(private readonly ctx: RudderContext) {}
+
+  call(module: string, fn: string, args?: unknown): Promise<CallModuleFunctionClientResponse> {
+    return api.callModuleFunction(this.ctx, { module, fn }, { args });
+  }
+}

src/domains/ResourcesDomain.ts

@@ -0,0 +1,43 @@
+import type { RudderContext } from '../core/context.js';
+import { api } from '../generated/api.js';
+import type {
+  CreateResourceRowRequest,
+  ListResourceRowsResponse,
+  ResourceRow,
+  UpdateResourceRowRequest,
+} from '../generated/resources.js';
+
+export class ResourceHandle {
+  constructor(
+    private readonly ctx: RudderContext,
+    private readonly slug: string,
+  ) {}
+
+  list(): Promise<ListResourceRowsResponse> {
+    return api.listResourceRows(this.ctx, { slug: this.slug });
+  }
+
+  get(id: string): Promise<ResourceRow> {
+    return api.getResourceRow(this.ctx, { slug: this.slug, id });
+  }
+
+  create(body: CreateResourceRowRequest): Promise<ResourceRow> {
+    return api.createResourceRow(this.ctx, { slug: this.slug }, body);
+  }
+
+  update(id: string, body: UpdateResourceRowRequest): Promise<ResourceRow> {
+    return api.updateResourceRow(this.ctx, { slug: this.slug, id }, body);
+  }
+
+  delete(id: string): Promise<void> {
+    return api.deleteResourceRow(this.ctx, { slug: this.slug, id });
+  }
+}
+
+export class ResourcesDomain {
+  constructor(private readonly ctx: RudderContext) {}
+
+  of(slug: string): ResourceHandle {
+    return new ResourceHandle(this.ctx, slug);
+  }
+}

src/domains/StoresDomain.ts

@@ -1,62 +0,0 @@
-import { SyncedState } from '../state/SyncedState.js';
-import type { RudderContext } from '../core/context.js';
-import { api } from '../generated/api.js';
-import { ShopHandle, type BuyOptions, type PurchaseOffer } from '../state/shops.js';
-import type { PurchaseOfferResponse } from '../generated/stores.js';
-
-/**
- * StoresDomain — the observable list of stores, plus the purchase executor
- * that every offer/store handle shares. Synced under revision key `stores`.
- *
- * A successful purchase runs `onPurchase`, which the client wires to invalidate
- * the profile, inventory, and store list so subscribers observe fresh data.
- */
-export class StoresDomain extends SyncedState<ShopHandle[]> {
-  readonly syncKey = 'stores';
-
-  /** Shared purchase executor: `stores.purchase(slug, offerSlug, opts)`. */
-  readonly purchase: PurchaseOffer;
-
-  private readonly ctx: RudderContext;
-
-  constructor(ctx: RudderContext, onPurchase: () => void) {
-    // Built before super() so it captures params, not `this`; the store/offer
-    // handles created in the loader all delegate to this one executor.
-    const purchase: PurchaseOffer = async (
-      storeSlug: string,
-      offerSlug: string,
-      options: BuyOptions = {},
-    ): Promise<PurchaseOfferResponse> => {
-      const response = await api.purchaseOffer(
-        ctx,
-        { storeSlug, offerSlug },
-        {
-          storeSlug,
-          offerSlug,
-          idempotencyKey: options.idempotencyKey ?? crypto.randomUUID(),
-        },
-      );
-      onPurchase();
-      return response;
-    };
-
-    super(async () => {
-      const response = await api.listSdkStores(ctx);
-      return (response.stores ?? []).map((store) => new ShopHandle(purchase, store));
-    });
-
-    this.ctx = ctx;
-    this.purchase = purchase;
-  }
-
-  /**
-   * Resolves a store by slug (cache-first). Used by scenario store nodes.
-   * @internal
-   */
-  async getBySlug(slug: string): Promise<ShopHandle> {
-    const cached = this.data?.find((store) => store.slug === slug);
-    if (cached) return cached;
-    const store = await api.getStore(this.ctx, { slug });
-    return new ShopHandle(this.purchase, store);
-  }
-}