@jskit-ai/rewarded-core 0.1.120

package/src/shared/rewardedProviderConfigResource.js

@@ -0,0 +1,95 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "rewarded_provider_configs",
+  tableName: "rewarded_provider_configs",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  surface: {
+    type: "string",
+    maxLength: 64,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  enabled: {
+    type: "boolean",
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  placement: {
+    type: "string",
+    maxLength: 255,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  provider: {
+    type: "string",
+    maxLength: 64,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  updatedAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["surface","placement","provider"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/src/shared/rewardedRuleResource.js

@@ -0,0 +1,136 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "rewarded_rules",
+  tableName: "rewarded_rules",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  gateKey: {
+    type: "string",
+    maxLength: 120,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  surface: {
+    type: "string",
+    maxLength: 64,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  enabled: {
+    type: "boolean",
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  unlockMinutes: {
+    type: "integer",
+    min: 0,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  cooldownMinutes: {
+    type: "integer",
+    min: 0,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  dailyLimit: {
+    type: "integer",
+    min: 0,
+    nullable: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  title: {
+    type: "string",
+    maxLength: 160,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  description: {
+    type: "string",
+    maxLength: 65535,
+    nullable: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  updatedAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["gateKey","surface","title","description"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/src/shared/rewardedUnlockReceiptResource.js

@@ -0,0 +1,113 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "rewarded_unlock_receipts",
+  tableName: "rewarded_unlock_receipts",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  userId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  gateKey: {
+    type: "string",
+    maxLength: 120,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  providerConfigId: {
+    type: "id",
+    nullable: true,
+    search: true,
+    relation: { kind: "lookup", namespace: "rewarded-provider-configs", valueKey: "id" },
+    belongsTo: "rewardedProviderConfigs",
+    as: "providerConfig",
+    ui: { formControl: "autocomplete" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  watchSessionId: {
+    type: "id",
+    nullable: true,
+    search: true,
+    relation: { kind: "lookup", namespace: "rewarded-watch-sessions", valueKey: "id" },
+    belongsTo: "rewardedWatchSessions",
+    as: "watchSession",
+    ui: { formControl: "autocomplete" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  grantedAt: {
+    type: "dateTime",
+    default: "now()",
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  unlockedUntil: {
+    type: "dateTime",
+    required: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["gateKey"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace_user",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/src/shared/rewardedWatchSessionResource.js

@@ -0,0 +1,139 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "rewarded_watch_sessions",
+  tableName: "rewarded_watch_sessions",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  userId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  gateKey: {
+    type: "string",
+    maxLength: 120,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  providerConfigId: {
+    type: "id",
+    nullable: true,
+    search: true,
+    relation: { kind: "lookup", namespace: "rewarded-provider-configs", valueKey: "id" },
+    belongsTo: "rewardedProviderConfigs",
+    as: "providerConfig",
+    ui: { formControl: "autocomplete" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  status: {
+    type: "string",
+    maxLength: 32,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  startedAt: {
+    type: "dateTime",
+    default: "now()",
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  rewardedAt: {
+    type: "dateTime",
+    nullable: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  completedAt: {
+    type: "dateTime",
+    nullable: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  closedAt: {
+    type: "dateTime",
+    nullable: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  updatedAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["gateKey","status"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace_user",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/test/featureRuntime.test.js

@@ -0,0 +1,91 @@
+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 { RewardedCoreFeature } from "../src/server/RewardedCoreProvider.js";
+import {
+  RewardedProviderConfigsFeature,
+  RewardedRulesFeature,
+  RewardedUnlockReceiptsFeature,
+  RewardedWatchSessionsFeature
+} from "../src/server/RewardedResources.js";
+
+function valueProvider(id, capability, value) {
+  return defineProvider({
+    id,
+    provides: { value: capability },
+    setup() {
+      return { value };
+    }
+  });
+}
+
+test("Rewarded composes standard resource capabilities around one explicit domain feature", async () => {
+  const routes = [];
+  const resources = {};
+  let actions;
+  let rewarded;
+  const knex = Object.assign(() => {}, {
+    async transaction(callback) {
+      return callback({});
+    }
+  });
+  const runtime = createCapabilityRuntime({
+    providers: [
+      createActionProvider(),
+      valueProvider("test.grant-policy", "rewarded.grant-policy", { authorizeGrant: async () => false }),
+      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 };
+        }
+      }),
+      RewardedRulesFeature,
+      RewardedProviderConfigsFeature,
+      RewardedWatchSessionsFeature,
+      RewardedUnlockReceiptsFeature,
+      RewardedCoreFeature,
+      defineProvider({
+        id: "test.observer",
+        requires: {
+          actionCatalogue: "runtime.actions",
+          rewarded: "rewarded.core"
+        },
+        setup(dependencies) {
+          actions = dependencies.actionCatalogue;
+          rewarded = dependencies.rewarded;
+          return {};
+        }
+      })
+    ]
+  });
+
+  await runtime.start();
+
+  const definitions = actions.listDefinitions();
+  assert.equal(definitions.length, 24);
+  assert.deepEqual(
+    definitions.slice(-4).map((entry) => entry.id),
+    [
+      "rewarded.current.read",
+      "rewarded.start",
+      "rewarded.grant",
+      "rewarded.close"
+    ]
+  );
+  assert.ok(definitions.every((entry) => !Object.hasOwn(entry, "dependencies")));
+  assert.equal(typeof rewarded.getCurrentState, "function");
+  assert.equal(routes.length, 24);
+  assert.equal(Object.keys(resources).length, 4);
+
+  await runtime.shutdown();
+});