@jskit-ai/rewarded-core 0.1.120

package/src/server/RewardedResources.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/rewardedProviderConfigResource.js";
+import { resource as ruleResource } from "../shared/rewardedRuleResource.js";
+import { resource as unlockReceiptResource } from "../shared/rewardedUnlockReceiptResource.js";
+import { resource as watchSessionResource } from "../shared/rewardedWatchSessionResource.js";
+
+function workspaceScope() {
+  return {
+    routeBase: "/w/:workspaceSlug",
+    actionInputValidator: workspaceSlugParamsValidator,
+    routeParamsValidator,
+    inputKeys: ["workspaceSlug"],
+    input: (request) => buildWorkspaceInputFromRouteParams(request.input.params)
+  };
+}
+
+const RewardedRulesFeature = defineCrudJsonApiFeature({
+  id: "rewarded.rules",
+  capability: "rewarded.rules",
+  resource: ruleResource,
+  surface: "admin",
+  ownershipFilter: "workspace",
+  relativePath: "/rewarded-rules",
+  internal: true,
+  scope: workspaceScope()
+});
+
+const RewardedProviderConfigsFeature = defineCrudJsonApiFeature({
+  id: "rewarded.provider-configs",
+  capability: "rewarded.provider-configs",
+  resource: providerConfigResource,
+  surface: "admin",
+  ownershipFilter: "workspace",
+  relativePath: "/rewarded-provider-configs",
+  internal: true,
+  scope: workspaceScope()
+});
+
+const RewardedWatchSessionsFeature = defineCrudJsonApiFeature({
+  id: "rewarded.watch-sessions",
+  capability: "rewarded.watch-sessions",
+  resource: watchSessionResource,
+  surface: "admin",
+  ownershipFilter: "workspace_user",
+  relativePath: "/rewarded-watch-sessions",
+  internal: true,
+  scope: workspaceScope()
+});
+
+const RewardedUnlockReceiptsFeature = defineCrudJsonApiFeature({
+  id: "rewarded.unlock-receipts",
+  capability: "rewarded.unlock-receipts",
+  resource: unlockReceiptResource,
+  surface: "admin",
+  ownershipFilter: "workspace_user",
+  relativePath: "/rewarded-unlock-receipts",
+  internal: true,
+  scope: workspaceScope()
+});
+
+export {
+  RewardedProviderConfigsFeature,
+  RewardedRulesFeature,
+  RewardedUnlockReceiptsFeature,
+  RewardedWatchSessionsFeature
+};

package/src/server/actions.js

@@ -0,0 +1,152 @@
+import {
+  currentQueryInputValidator,
+  startCommandInputValidator,
+  grantCommandInputValidator,
+  closeCommandInputValidator,
+  currentStateOutputValidator,
+  startGateOutputValidator,
+  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 = "rewarded.current.read";
+const ACTION_START = "rewarded.start";
+const ACTION_GRANT = "rewarded.grant";
+const ACTION_CLOSE = "rewarded.close";
+
+const watchSessionChanged = resolveCrudRecordChangedEvent("rewarded_watch_sessions");
+const unlockReceiptChanged = resolveCrudRecordChangedEvent("rewarded_unlock_receipts");
+
+function changedEvent({ entity, operation, entityId, event }) {
+  return createEntityChangedActionEvent({
+    source: "rewarded",
+    entity,
+    operation,
+    entityId,
+    realtime: { event, audience: "event_scope" }
+  });
+}
+
+function createRewardedActions({ rewarded } = {}) {
+  if (!rewarded) {
+    throw new TypeError("createRewardedActions requires rewarded.");
+  }
+  return Object.freeze([
+  {
+    id: ACTION_CURRENT,
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
+    input: currentQueryInputValidator,
+    output: currentStateOutputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: ACTION_CURRENT
+    },
+    observability: {},
+    async execute(input, context) {
+      return rewarded.getCurrentState(input, {
+        context
+      });
+    }
+  },
+  {
+    id: ACTION_START,
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
+    input: startCommandInputValidator,
+    output: startGateOutputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: ACTION_START
+    },
+    observability: {},
+    events: [changedEvent({
+      entity: "watch-session",
+      operation: "created",
+      entityId: ({ result }) => result?.session?.id,
+      event: watchSessionChanged
+    })],
+    async execute(input, context) {
+      return rewarded.startGate(input, {
+        context
+      });
+    }
+  },
+  {
+    id: ACTION_GRANT,
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
+    input: grantCommandInputValidator,
+    output: grantRewardOutputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: ACTION_GRANT
+    },
+    observability: {},
+    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 rewarded.grantReward(input, {
+        context
+      });
+    }
+  },
+  {
+    id: ACTION_CLOSE,
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfaces: ["app"],
+    permission: { require: "authenticated" },
+    input: closeCommandInputValidator,
+    output: closeSessionOutputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: ACTION_CLOSE
+    },
+    observability: {},
+    events: [changedEvent({
+      entity: "watch-session",
+      operation: "updated",
+      entityId: ({ result }) => result?.session?.id,
+      event: watchSessionChanged
+    })],
+    async execute(input, context) {
+      return rewarded.closeSession(input, {
+        context
+      });
+    }
+  }
+  ]);
+}
+
+export {
+  ACTION_CURRENT,
+  ACTION_START,
+  ACTION_GRANT,
+  ACTION_CLOSE,
+  createRewardedActions
+};

package/src/server/inputSchemas.js

@@ -0,0 +1,394 @@
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
+
+const gateQuerySchema = createSchema({
+  gateKey: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 120
+  },
+  workspaceSlug: {
+    type: "string",
+    required: false,
+    minLength: 1,
+    maxLength: 120
+  }
+});
+
+const currentQueryInputValidator = deepFreeze({
+  schema: gateQuerySchema,
+  mode: "patch"
+});
+
+const startCommandInputValidator = deepFreeze({
+  schema: gateQuerySchema,
+  mode: "patch"
+});
+
+const grantCommandInputValidator = deepFreeze({
+  schema: createSchema({
+    sessionId: {
+      type: "id",
+      required: true
+    },
+    workspaceSlug: {
+      type: "string",
+      required: false,
+      minLength: 1,
+      maxLength: 120
+    }
+  }),
+  mode: "patch"
+});
+
+const closeCommandInputValidator = deepFreeze({
+  schema: createSchema({
+    sessionId: {
+      type: "id",
+      required: true
+    },
+    workspaceSlug: {
+      type: "string",
+      required: false,
+      minLength: 1,
+      maxLength: 120
+    }
+  }),
+  mode: "patch"
+});
+
+const gateRuleOutputSchema = createSchema({
+  id: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  gateKey: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 120
+  },
+  surface: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 64
+  },
+  enabled: {
+    type: "boolean",
+    required: true
+  },
+  unlockMinutes: {
+    type: "integer",
+    required: true,
+    min: 0
+  },
+  cooldownMinutes: {
+    type: "integer",
+    required: true,
+    min: 0
+  },
+  dailyLimit: {
+    type: "integer",
+    required: false,
+    nullable: true,
+    min: 0
+  },
+  title: {
+    type: "string",
+    required: true
+  },
+  description: {
+    type: "string",
+    required: true
+  }
+});
+
+const providerConfigOutputSchema = createSchema({
+  id: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  surface: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 64
+  },
+  enabled: {
+    type: "boolean",
+    required: true
+  },
+  placement: {
+    type: "string",
+    required: true
+  },
+  provider: {
+    type: "string",
+    required: true
+  }
+});
+
+const watchSessionOutputSchema = createSchema({
+  id: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  gateKey: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 120
+  },
+  providerConfigId: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  status: {
+    type: "string",
+    required: true,
+    minLength: 1
+  },
+  startedAt: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  rewardedAt: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  completedAt: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  closedAt: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  }
+});
+
+const unlockReceiptOutputSchema = createSchema({
+  id: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  gateKey: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 120
+  },
+  providerConfigId: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  watchSessionId: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  grantedAt: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  },
+  unlockedUntil: {
+    type: "string",
+    required: false,
+    nullable: true,
+    minLength: 1
+  }
+});
+
+function createGateStateOutputValidator({
+  includeSession = false
+} = {}) {
+  const fields = {
+    gateKey: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 120
+    },
+    workspaceSlug: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 120
+    },
+    surface: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 64
+    },
+    enabled: {
+      type: "boolean",
+      required: true
+    },
+    available: {
+      type: "boolean",
+      required: true
+    },
+    blocked: {
+      type: "boolean",
+      required: true
+    },
+    reason: {
+      type: "string",
+      required: true,
+      minLength: 1
+    },
+    rule: {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: gateRuleOutputSchema
+    },
+    providerConfig: {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: providerConfigOutputSchema
+    },
+    unlock: {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: unlockReceiptOutputSchema
+    },
+    cooldownUntil: {
+      type: "string",
+      required: false,
+      nullable: true,
+      minLength: 1
+    },
+    dailyLimitRemaining: {
+      type: "integer",
+      required: false,
+      nullable: true,
+      min: 0
+    }
+  };
+
+  if (includeSession === true) {
+    fields.session = {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: watchSessionOutputSchema
+    };
+  }
+
+  return deepFreeze({
+    schema: createSchema(fields),
+    mode: "replace"
+  });
+}
+
+const currentStateOutputValidator = createGateStateOutputValidator();
+const startGateOutputValidator = createGateStateOutputValidator({
+  includeSession: true
+});
+
+const grantRewardOutputValidator = deepFreeze({
+  schema: createSchema({
+    unlocked: {
+      type: "boolean",
+      required: true
+    },
+    workspaceSlug: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 120
+    },
+    gateKey: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 120
+    },
+    unlock: {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: unlockReceiptOutputSchema
+    },
+    session: {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: watchSessionOutputSchema
+    }
+  }),
+  mode: "replace"
+});
+
+const closeSessionOutputValidator = deepFreeze({
+  schema: createSchema({
+    closed: {
+      type: "boolean",
+      required: true
+    },
+    workspaceSlug: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 120
+    },
+    gateKey: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 120
+    },
+    session: {
+      type: "object",
+      required: false,
+      nullable: true,
+      schema: watchSessionOutputSchema
+    },
+    reason: {
+      type: "string",
+      required: false,
+      nullable: true,
+      minLength: 1
+    }
+  }),
+  mode: "replace"
+});
+
+export {
+  currentQueryInputValidator,
+  startCommandInputValidator,
+  grantCommandInputValidator,
+  closeCommandInputValidator,
+  currentStateOutputValidator,
+  startGateOutputValidator,
+  grantRewardOutputValidator,
+  closeSessionOutputValidator
+};