@jskit-ai/google-rewarded-core 0.1.95 → 0.1.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/google-rewarded-core",
-  "version": "0.1.95",
+  "version": "0.1.97",
   "type": "module",
   "exports": {
     "./shared": "./src/shared/index.js",
@@ -12,41 +12,41 @@
     "kind": "runtime",
     "capabilities": {
       "provides": [
-        "crud.google-rewarded-rules",
-        "crud.google-rewarded-provider-configs",
-        "crud.google-rewarded-watch-sessions",
-        "crud.google-rewarded-unlock-receipts",
+        "google-rewarded.rules",
+        "google-rewarded.provider-configs",
+        "google-rewarded.watch-sessions",
+        "google-rewarded.unlock-receipts",
         "google-rewarded.core"
       ],
       "requires": [
         "runtime.actions",
         "runtime.database",
-        "auth.policy",
-        "json-rest-api.core"
+        "runtime.http",
+        "runtime.json-rest-api"
       ]
     },
     "runtime": {
       "server": {
         "providers": [
           {
-            "entrypoint": "src/server/rules/GoogleRewardedRulesProvider.js",
-            "export": "GoogleRewardedRulesProvider"
+            "entrypoint": "src/server/GoogleRewardedResources.js",
+            "export": "GoogleRewardedRulesFeature"
           },
           {
-            "entrypoint": "src/server/providerConfigs/GoogleRewardedProviderConfigsProvider.js",
-            "export": "GoogleRewardedProviderConfigsProvider"
+            "entrypoint": "src/server/GoogleRewardedResources.js",
+            "export": "GoogleRewardedProviderConfigsFeature"
           },
           {
-            "entrypoint": "src/server/watchSessions/GoogleRewardedWatchSessionsProvider.js",
-            "export": "GoogleRewardedWatchSessionsProvider"
+            "entrypoint": "src/server/GoogleRewardedResources.js",
+            "export": "GoogleRewardedWatchSessionsFeature"
           },
           {
-            "entrypoint": "src/server/unlockReceipts/GoogleRewardedUnlockReceiptsProvider.js",
-            "export": "GoogleRewardedUnlockReceiptsProvider"
+            "entrypoint": "src/server/GoogleRewardedResources.js",
+            "export": "GoogleRewardedUnlockReceiptsFeature"
           },
           {
             "entrypoint": "src/server/GoogleRewardedCoreProvider.js",
-            "export": "GoogleRewardedCoreProvider"
+            "export": "GoogleRewardedCoreFeature"
           }
         ]
       },
@@ -56,35 +56,26 @@
     },
     "metadata": {
       "jskit": {
-        "scaffoldShape": "crud-server-v1",
         "tableOwnership": {
           "tables": [
             {
               "tableName": "google_rewarded_rules",
-              "provenance": "crud-server-generator",
-              "ownerKind": "crud-package",
-              "providerEntrypoint": "src/server/rules/GoogleRewardedRulesProvider.js",
+              "providerEntrypoint": "src/server/GoogleRewardedResources.js",
               "ownershipFilter": "workspace"
             },
             {
               "tableName": "google_rewarded_provider_configs",
-              "provenance": "crud-server-generator",
-              "ownerKind": "crud-package",
-              "providerEntrypoint": "src/server/providerConfigs/GoogleRewardedProviderConfigsProvider.js",
+              "providerEntrypoint": "src/server/GoogleRewardedResources.js",
               "ownershipFilter": "workspace"
             },
             {
               "tableName": "google_rewarded_watch_sessions",
-              "provenance": "crud-server-generator",
-              "ownerKind": "crud-package",
-              "providerEntrypoint": "src/server/watchSessions/GoogleRewardedWatchSessionsProvider.js",
+              "providerEntrypoint": "src/server/GoogleRewardedResources.js",
               "ownershipFilter": "workspace_user"
             },
             {
               "tableName": "google_rewarded_unlock_receipts",
-              "provenance": "crud-server-generator",
-              "ownerKind": "crud-package",
-              "providerEntrypoint": "src/server/unlockReceipts/GoogleRewardedUnlockReceiptsProvider.js",
+              "providerEntrypoint": "src/server/GoogleRewardedResources.js",
               "ownershipFilter": "workspace_user"
             }
           ]
@@ -105,89 +96,29 @@
             "summary": "Exports the server helper that enforces a rewarded unlock before a protected feature action continues."
           }
         ],
-        "containerTokens": {
-          "server": [
-            "repository.google_rewarded_rules",
-            "crud.google_rewarded_rules",
-            "repository.google_rewarded_provider_configs",
-            "crud.google_rewarded_provider_configs",
-            "repository.google_rewarded_watch_sessions",
-            "crud.google_rewarded_watch_sessions",
-            "repository.google_rewarded_unlock_receipts",
-            "crud.google_rewarded_unlock_receipts",
-            "google-rewarded.core.service"
-          ],
-          "client": []
-        }
+        "capabilities": [
+          "google-rewarded.rules",
+          "google-rewarded.provider-configs",
+          "google-rewarded.watch-sessions",
+          "google-rewarded.unlock-receipts",
+          "google-rewarded.core"
+        ]
       }
     },
-    "mutations": {
-      "dependencies": {
-        "runtime": {
-          "@jskit-ai/auth-core": "0.1.157",
-          "@jskit-ai/crud-core": "0.1.170",
-          "@jskit-ai/database-runtime": "0.1.159",
-          "@jskit-ai/http-runtime": "0.1.157",
-          "@jskit-ai/json-rest-api-core": "0.1.103",
-          "@jskit-ai/kernel": "0.1.159",
-          "@jskit-ai/resource-crud-core": "0.1.101",
-          "@jskit-ai/workspaces-core": "0.1.137"
-        },
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {}
-      },
-      "procfile": {},
-      "files": [
-        {
-          "op": "install-migration",
-          "from": "templates/migrations/google_rewarded_rules_initial.cjs",
-          "toDir": "migrations",
-          "extension": ".cjs",
-          "reason": "Install Google rewarded rules schema migration.",
-          "category": "google-rewarded",
-          "id": "google-rewarded-rules-initial-schema"
-        },
-        {
-          "op": "install-migration",
-          "from": "templates/migrations/google_rewarded_provider_configs_initial.cjs",
-          "toDir": "migrations",
-          "extension": ".cjs",
-          "reason": "Install Google rewarded provider config schema migration.",
-          "category": "google-rewarded",
-          "id": "google-rewarded-provider-configs-initial-schema"
-        },
-        {
-          "op": "install-migration",
-          "from": "templates/migrations/google_rewarded_watch_sessions_initial.cjs",
-          "toDir": "migrations",
-          "extension": ".cjs",
-          "reason": "Install Google rewarded watch sessions schema migration.",
-          "category": "google-rewarded",
-          "id": "google-rewarded-watch-sessions-initial-schema"
-        },
-        {
-          "op": "install-migration",
-          "from": "templates/migrations/google_rewarded_unlock_receipts_initial.cjs",
-          "toDir": "migrations",
-          "extension": ".cjs",
-          "reason": "Install Google rewarded unlock receipts schema migration.",
-          "category": "google-rewarded",
-          "id": "google-rewarded-unlock-receipts-initial-schema"
-        }
-      ],
-      "text": []
+    "migrations": {
+      "directories": [
+        "migrations"
+      ]
     }
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.157",
-    "@jskit-ai/crud-core": "0.1.170",
-    "@jskit-ai/database-runtime": "0.1.159",
-    "@jskit-ai/http-runtime": "0.1.157",
-    "@jskit-ai/json-rest-api-core": "0.1.103",
-    "@jskit-ai/kernel": "0.1.159",
-    "@jskit-ai/resource-crud-core": "0.1.101",
-    "@jskit-ai/workspaces-core": "0.1.137"
+    "@jskit-ai/auth-core": "0.1.159",
+    "@jskit-ai/crud-core": "0.1.172",
+    "@jskit-ai/database-runtime": "0.1.161",
+    "@jskit-ai/http-runtime": "0.1.159",
+    "@jskit-ai/json-rest-api-core": "0.1.105",
+    "@jskit-ai/kernel": "0.1.161",
+    "@jskit-ai/resource-crud-core": "0.1.103",
+    "@jskit-ai/workspaces-core": "0.1.139"
   }
 }

package/src/server/GoogleRewardedCoreProvider.js

@@ -1,51 +1,39 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { defineFeature } from "@jskit-ai/kernel/server/features";
 
 import { createService } from "./service.js";
-import { googleRewardedActions } from "./actions.js";
+import { createGoogleRewardedActions } from "./actions.js";
 import { registerRoutes } from "./registerRoutes.js";
 
-class GoogleRewardedCoreProvider {
-  static id = "google-rewarded.core";
-
-  static startsAfter = ["runtime.actions"];
-
-  register(app) {
-    if (
-      !app ||
-      typeof app.singleton !== "function" ||
-      typeof app.service !== "function" ||
-      typeof app.actions !== "function"
-    ) {
-      throw new Error("GoogleRewardedCoreProvider requires application singleton()/service()/actions().");
-    }
-
-    app.service(
-      "google-rewarded.core.service",
-      (scope) => createService({
-        googleRewardedRulesRepository: scope.make("repository.google_rewarded_rules"),
-        googleRewardedProviderConfigsRepository: scope.make("repository.google_rewarded_provider_configs"),
-        googleRewardedWatchSessionsRepository: scope.make("repository.google_rewarded_watch_sessions"),
-        googleRewardedUnlockReceiptsRepository: scope.make("repository.google_rewarded_unlock_receipts")
-      })
-    );
-
-    app.actions(
-      withActionDefaults(googleRewardedActions, {
-        domain: "google-rewarded",
-        dependencies: {
-          googleRewardedService: "google-rewarded.core.service"
-        }
-      })
-    );
-  }
-
-  boot(app) {
-    registerRoutes(app, {
+const GoogleRewardedCoreFeature = defineFeature({
+  id: "google-rewarded.core",
+  domain: "google-rewarded",
+  requires: {
+    http: "runtime.http",
+    providerConfigs: "google-rewarded.provider-configs",
+    rules: "google-rewarded.rules",
+    unlockReceipts: "google-rewarded.unlock-receipts",
+    watchSessions: "google-rewarded.watch-sessions"
+  },
+  provides: {
+    googleRewarded: "google-rewarded.core"
+  },
+  setup({ http, providerConfigs, rules, unlockReceipts, watchSessions }) {
+    const googleRewarded = createService({
+      googleRewardedRulesRepository: rules.repository,
+      googleRewardedProviderConfigsRepository: providerConfigs.repository,
+      googleRewardedWatchSessionsRepository: watchSessions.repository,
+      googleRewardedUnlockReceiptsRepository: unlockReceipts.repository
+    });
+    registerRoutes(http.router, {
       routeOwnershipFilter: "workspace_user",
       routeSurface: "app",
       routeRelativePath: "google-rewarded"
     });
+    return { googleRewarded };
+  },
+  actions({ googleRewarded }) {
+    return createGoogleRewardedActions({ googleRewarded });
   }
-}
+});
 
-export { GoogleRewardedCoreProvider };
+export { GoogleRewardedCoreFeature };

package/src/server/GoogleRewardedResources.js

@@ -0,0 +1,69 @@
+import { defineCrudJsonApiFeature } from "@jskit-ai/crud-core/server/defineCrudJsonApiFeature";
+import { routeParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
+import { workspaceSlugParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
+import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/workspaces-core/server/support/workspaceRouteInput";
+import { resource as providerConfigResource } from "../shared/googleRewardedProviderConfigResource.js";
+import { resource as ruleResource } from "../shared/googleRewardedRuleResource.js";
+import { resource as unlockReceiptResource } from "../shared/googleRewardedUnlockReceiptResource.js";
+import { resource as watchSessionResource } from "../shared/googleRewardedWatchSessionResource.js";
+
+function workspaceScope() {
+  return {
+    routeBase: "/w/:workspaceSlug",
+    actionInputValidator: workspaceSlugParamsValidator,
+    routeParamsValidator,
+    inputKeys: ["workspaceSlug"],
+    input: (request) => buildWorkspaceInputFromRouteParams(request.input.params)
+  };
+}
+
+const GoogleRewardedRulesFeature = defineCrudJsonApiFeature({
+  id: "google-rewarded.rules",
+  capability: "google-rewarded.rules",
+  resource: ruleResource,
+  surface: "admin",
+  ownershipFilter: "workspace",
+  relativePath: "/google-rewarded-rules",
+  internal: true,
+  scope: workspaceScope()
+});
+
+const GoogleRewardedProviderConfigsFeature = defineCrudJsonApiFeature({
+  id: "google-rewarded.provider-configs",
+  capability: "google-rewarded.provider-configs",
+  resource: providerConfigResource,
+  surface: "admin",
+  ownershipFilter: "workspace",
+  relativePath: "/google-rewarded-provider-configs",
+  internal: true,
+  scope: workspaceScope()
+});
+
+const GoogleRewardedWatchSessionsFeature = defineCrudJsonApiFeature({
+  id: "google-rewarded.watch-sessions",
+  capability: "google-rewarded.watch-sessions",
+  resource: watchSessionResource,
+  surface: "admin",
+  ownershipFilter: "workspace_user",
+  relativePath: "/google-rewarded-watch-sessions",
+  internal: true,
+  scope: workspaceScope()
+});
+
+const GoogleRewardedUnlockReceiptsFeature = defineCrudJsonApiFeature({
+  id: "google-rewarded.unlock-receipts",
+  capability: "google-rewarded.unlock-receipts",
+  resource: unlockReceiptResource,
+  surface: "admin",
+  ownershipFilter: "workspace_user",
+  relativePath: "/google-rewarded-unlock-receipts",
+  internal: true,
+  scope: workspaceScope()
+});
+
+export {
+  GoogleRewardedProviderConfigsFeature,
+  GoogleRewardedRulesFeature,
+  GoogleRewardedUnlockReceiptsFeature,
+  GoogleRewardedWatchSessionsFeature
+};

package/src/server/actions.js

@@ -8,19 +8,39 @@ import {
   grantRewardOutputValidator,
   closeSessionOutputValidator
 } from "./inputSchemas.js";
+import { createEntityChangedActionEvent } from "@jskit-ai/kernel/server/actions";
+import { resolveCrudRecordChangedEvent } from "@jskit-ai/resource-crud-core/shared/crudNamespaceSupport";
 
 const ACTION_CURRENT = "google-rewarded.current.read";
 const ACTION_START = "google-rewarded.start";
 const ACTION_GRANT = "google-rewarded.grant";
 const ACTION_CLOSE = "google-rewarded.close";
 
-const googleRewardedActions = Object.freeze([
+const watchSessionChanged = resolveCrudRecordChangedEvent("google_rewarded_watch_sessions");
+const unlockReceiptChanged = resolveCrudRecordChangedEvent("google_rewarded_unlock_receipts");
+
+function changedEvent({ entity, operation, entityId, event }) {
+  return createEntityChangedActionEvent({
+    source: "google-rewarded",
+    entity,
+    operation,
+    entityId,
+    realtime: { event, audience: "event_scope" }
+  });
+}
+
+function createGoogleRewardedActions({ googleRewarded } = {}) {
+  if (!googleRewarded) {
+    throw new TypeError("createGoogleRewardedActions requires googleRewarded.");
+  }
+  return Object.freeze([
   {
     id: ACTION_CURRENT,
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
     input: currentQueryInputValidator,
     output: currentStateOutputValidator,
     idempotency: "none",
@@ -28,8 +48,8 @@ const googleRewardedActions = Object.freeze([
       actionName: ACTION_CURRENT
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.googleRewardedService.getCurrentState(input, {
+    async execute(input, context) {
+      return googleRewarded.getCurrentState(input, {
         context
       });
     }
@@ -39,7 +59,8 @@ const googleRewardedActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
     input: startCommandInputValidator,
     output: startGateOutputValidator,
     idempotency: "optional",
@@ -47,8 +68,14 @@ const googleRewardedActions = Object.freeze([
       actionName: ACTION_START
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.googleRewardedService.startGate(input, {
+    events: [changedEvent({
+      entity: "watch-session",
+      operation: "created",
+      entityId: ({ result }) => result?.session?.id,
+      event: watchSessionChanged
+    })],
+    async execute(input, context) {
+      return googleRewarded.startGate(input, {
         context
       });
     }
@@ -58,7 +85,8 @@ const googleRewardedActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
     input: grantCommandInputValidator,
     output: grantRewardOutputValidator,
     idempotency: "optional",
@@ -66,8 +94,22 @@ const googleRewardedActions = Object.freeze([
       actionName: ACTION_GRANT
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.googleRewardedService.grantReward(input, {
+    events: [
+      changedEvent({
+        entity: "watch-session",
+        operation: "updated",
+        entityId: ({ result }) => result?.session?.id,
+        event: watchSessionChanged
+      }),
+      changedEvent({
+        entity: "unlock-receipt",
+        operation: "created",
+        entityId: ({ result }) => result?.unlock?.id,
+        event: unlockReceiptChanged
+      })
+    ],
+    async execute(input, context) {
+      return googleRewarded.grantReward(input, {
         context
       });
     }
@@ -77,7 +119,8 @@ const googleRewardedActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
     input: closeCommandInputValidator,
     output: closeSessionOutputValidator,
     idempotency: "optional",
@@ -85,18 +128,25 @@ const googleRewardedActions = Object.freeze([
       actionName: ACTION_CLOSE
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.googleRewardedService.closeSession(input, {
+    events: [changedEvent({
+      entity: "watch-session",
+      operation: "updated",
+      entityId: ({ result }) => result?.session?.id,
+      event: watchSessionChanged
+    })],
+    async execute(input, context) {
+      return googleRewarded.closeSession(input, {
         context
       });
     }
   }
-]);
+  ]);
+}
 
 export {
   ACTION_CURRENT,
   ACTION_START,
   ACTION_GRANT,
   ACTION_CLOSE,
-  googleRewardedActions
+  createGoogleRewardedActions
 };

package/src/server/registerRoutes.js

@@ -37,18 +37,16 @@ function createWorkflowResponses(outputValidator) {
 }
 
 function registerRoutes(
-  app,
+  router,
   {
     routeOwnershipFilter = "workspace_user",
     routeSurface = "app",
     routeRelativePath = "google-rewarded"
   } = {}
 ) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("registerRoutes requires application make().");
+  if (!router || typeof router.register !== "function") {
+    throw new Error("registerRoutes requires an HTTP router.");
   }
-
-  const router = app.make("jskit.http.router");
   const normalizedRouteSurface = normalizeSurfaceId(routeSurface);
   const routeBase = resolveScopedApiBasePath({
     routeBase: "/w/:workspaceSlug",

package/test/featureRuntime.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { GoogleRewardedCoreFeature } from "../src/server/GoogleRewardedCoreProvider.js";
+import {
+  GoogleRewardedProviderConfigsFeature,
+  GoogleRewardedRulesFeature,
+  GoogleRewardedUnlockReceiptsFeature,
+  GoogleRewardedWatchSessionsFeature
+} from "../src/server/GoogleRewardedResources.js";
+
+function valueProvider(id, capability, value) {
+  return defineProvider({
+    id,
+    provides: { value: capability },
+    setup() {
+      return { value };
+    }
+  });
+}
+
+test("Google rewarded composes standard resource capabilities around one explicit domain feature", async () => {
+  const routes = [];
+  const resources = {};
+  let actions;
+  let googleRewarded;
+  const knex = Object.assign(() => {}, {
+    async transaction(callback) {
+      return callback({});
+    }
+  });
+  const runtime = createCapabilityRuntime({
+    providers: [
+      createActionProvider(),
+      valueProvider("test.database", "runtime.database", { knex }),
+      valueProvider("test.http", "runtime.http", {
+        router: {
+          register(method, path, contract, handler) {
+            routes.push({ method, path, contract, handler });
+          }
+        }
+      }),
+      valueProvider("test.json-rest-api", "runtime.json-rest-api", {
+        resources,
+        async addResource(name, config) {
+          resources[name] = { config };
+        }
+      }),
+      GoogleRewardedRulesFeature,
+      GoogleRewardedProviderConfigsFeature,
+      GoogleRewardedWatchSessionsFeature,
+      GoogleRewardedUnlockReceiptsFeature,
+      GoogleRewardedCoreFeature,
+      defineProvider({
+        id: "test.observer",
+        requires: {
+          actionCatalogue: "runtime.actions",
+          rewarded: "google-rewarded.core"
+        },
+        setup(dependencies) {
+          actions = dependencies.actionCatalogue;
+          googleRewarded = dependencies.rewarded;
+          return {};
+        }
+      })
+    ]
+  });
+
+  await runtime.start();
+
+  const definitions = actions.listDefinitions();
+  assert.equal(definitions.length, 24);
+  assert.deepEqual(
+    definitions.slice(-4).map((entry) => entry.id),
+    [
+      "google-rewarded.current.read",
+      "google-rewarded.start",
+      "google-rewarded.grant",
+      "google-rewarded.close"
+    ]
+  );
+  assert.ok(definitions.every((entry) => !Object.hasOwn(entry, "dependencies")));
+  assert.equal(typeof googleRewarded.getCurrentState, "function");
+  assert.equal(routes.length, 24);
+  assert.equal(Object.keys(resources).length, 4);
+
+  await runtime.shutdown();
+});

package/test/routes.test.js

@@ -35,16 +35,7 @@ function mountRoutes() {
     }
   };
 
-  const app = {
-    make(token) {
-      if (token !== "jskit.http.router") {
-        throw new Error(`Unexpected token: ${String(token)}`);
-      }
-      return router;
-    }
-  };
-
-  registerRoutes(app);
+  registerRoutes(router);
   return registeredRoutes;
 }