@jskit-ai/google-rewarded-core 0.1.1

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
+  },
+  adUnitPath: {
+    type: "string",
+    required: true
+  },
+  scriptMode: {
+    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
+};

package/src/server/providerConfigs/GoogleRewardedProviderConfigsProvider.js

@@ -0,0 +1,98 @@
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { resolveCrudSurfacePolicyFromAppConfig } from "@jskit-ai/crud-core/server/crudModuleConfig";
+import { createCrudJsonApiServiceEvents } from "@jskit-ai/crud-core/server/serviceEvents";
+import {
+  INTERNAL_JSON_REST_API,
+  addResourceIfMissing,
+  createJsonRestResourceScopeOptions
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
+import { createRepository } from "./repository.js";
+import { createService } from "./service.js";
+import { createActions } from "./actions.js";
+import { registerRoutes } from "./registerRoutes.js";
+import { resource } from "../../shared/googleRewardedProviderConfigResource.js";
+const CRUD_MODULE_CONFIG = Object.freeze({
+  namespace: "google_rewarded_provider_configs",
+  surface: "admin",
+  ownershipFilter: "workspace",
+  relativePath: "/google-rewarded-provider-configs"
+});
+const baseServiceEvents = createCrudJsonApiServiceEvents(CRUD_MODULE_CONFIG.namespace);
+const serviceEvents = {
+  ...baseServiceEvents
+};
+
+function resolveCrudPolicyFromApp(app) {
+  return resolveCrudSurfacePolicyFromAppConfig(CRUD_MODULE_CONFIG, resolveAppConfig(app), {
+    context: "GoogleRewardedProviderConfigsProvider"
+  });
+}
+
+class GoogleRewardedProviderConfigsProvider {
+  static id = "crud.google_rewarded_provider_configs";
+
+  static dependsOn = ["runtime.actions", "runtime.database", "auth.policy.fastify", "local.main", "json-rest-api.core"];
+
+  register(app) {
+    const crudPolicy = resolveCrudPolicyFromApp(app);
+
+    app.singleton("repository.google_rewarded_provider_configs", (scope) => {
+      const api = scope.make(INTERNAL_JSON_REST_API);
+      const knex = scope.make("jskit.database.knex");
+      return createRepository({
+        api,
+        knex
+      });
+    });
+
+    app.service(
+      "crud.google_rewarded_provider_configs",
+      (scope) => {
+        return createService({
+          googleRewardedProviderConfigsRepository: scope.make("repository.google_rewarded_provider_configs")
+        });
+      },
+      {
+        events: serviceEvents
+      }
+    );
+
+    app.actions(
+      withActionDefaults(
+        createActions({
+          surface: crudPolicy.surfaceId
+        }),
+        {
+          domain: "crud",
+          dependencies: {
+            googleRewardedProviderConfigsService: "crud.google_rewarded_provider_configs"
+          }
+        }
+      )
+    );
+  }
+
+  async boot(app) {
+    const crudPolicy = resolveCrudPolicyFromApp(app);
+    const api = app.make(INTERNAL_JSON_REST_API);
+    await addResourceIfMissing(
+      api,
+      "googleRewardedProviderConfigs",
+      createJsonRestResourceScopeOptions(resource, {
+        writeSerializers: {
+          "datetime-utc": toDatabaseDateTimeUtc
+        }
+      })
+    );
+    registerRoutes(app, {
+      routeOwnershipFilter: crudPolicy.ownershipFilter,
+      routeSurface: crudPolicy.surfaceId,
+      routeSurfaceRequiresWorkspace: crudPolicy.surfaceDefinition.requiresWorkspace === true,
+      routeRelativePath: crudPolicy.relativePath
+    });
+  }
+}
+
+export { GoogleRewardedProviderConfigsProvider };

package/src/server/providerConfigs/actions.js

@@ -0,0 +1,157 @@
+import {
+  composeSchemaDefinitions,
+  recordIdParamsValidator
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  createCrudCursorPaginationQueryValidator,
+  listSearchQueryValidator,
+  lookupIncludeQueryValidator,
+  createCrudParentFilterQueryValidator
+} from "@jskit-ai/crud-core/server/listQueryValidators";
+import { resource } from "../../shared/googleRewardedProviderConfigResource.js";
+import { workspaceSlugParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
+
+const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator({
+  orderBy: resource.defaultSort
+});
+const listParentFilterQueryValidator = createCrudParentFilterQueryValidator(resource);
+const actionPermissions = Object.freeze({
+  list: "crud.google_rewarded_provider_configs.list",
+  view: "crud.google_rewarded_provider_configs.view",
+  create: "crud.google_rewarded_provider_configs.create",
+  update: "crud.google_rewarded_provider_configs.update",
+  delete: "crud.google_rewarded_provider_configs.delete"
+});
+
+function createActions({ surface } = {}) {
+  return Object.freeze([
+    {
+      id: "crud.google_rewarded_provider_configs.list",
+      version: 1,
+      kind: "query",
+      channels: ["api", "automation", "internal"],
+      surfaces: [surface],
+      permission: { require: "all", permissions: [actionPermissions.list] },
+      input: composeSchemaDefinitions([
+  workspaceSlugParamsValidator,
+  listCursorPaginationQueryValidator,
+  listSearchQueryValidator,
+  listParentFilterQueryValidator,
+  lookupIncludeQueryValidator,
+]),
+      output: null,
+      idempotency: "none",
+      audit: {
+        actionName: "crud.google_rewarded_provider_configs.list"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        const { workspaceSlug, ...query } = input || {};
+        return deps.googleRewardedProviderConfigsService.queryDocuments(query, {
+          context
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_provider_configs.view",
+      version: 1,
+      kind: "query",
+      channels: ["api", "automation", "internal"],
+      surfaces: [surface],
+      permission: { require: "all", permissions: [actionPermissions.view] },
+      input: composeSchemaDefinitions([
+  workspaceSlugParamsValidator,
+  recordIdParamsValidator,
+  lookupIncludeQueryValidator,
+]),
+      output: null,
+      idempotency: "none",
+      audit: {
+        actionName: "crud.google_rewarded_provider_configs.view"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        return deps.googleRewardedProviderConfigsService.getDocumentById(input.recordId, {
+          context,
+          include: input.include
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_provider_configs.create",
+      version: 1,
+      kind: "command",
+      channels: ["api", "automation", "internal"],
+      surfaces: [surface],
+      permission: { require: "all", permissions: [actionPermissions.create] },
+      input: composeSchemaDefinitions([
+  workspaceSlugParamsValidator,
+  resource.operations.create.body,
+], {
+  mode: "create"
+}),
+      output: null,
+      idempotency: "optional",
+      audit: {
+        actionName: "crud.google_rewarded_provider_configs.create"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        const { workspaceSlug, ...payload } = input || {};
+        return deps.googleRewardedProviderConfigsService.createDocument(payload, {
+          context
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_provider_configs.update",
+      version: 1,
+      kind: "command",
+      channels: ["api", "automation", "internal"],
+      surfaces: [surface],
+      permission: { require: "all", permissions: [actionPermissions.update] },
+      input: composeSchemaDefinitions([
+  workspaceSlugParamsValidator,
+  recordIdParamsValidator,
+  resource.operations.patch.body,
+]),
+      output: null,
+      idempotency: "optional",
+      audit: {
+        actionName: "crud.google_rewarded_provider_configs.update"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        const { workspaceSlug, recordId, ...patch } = input || {};
+        return deps.googleRewardedProviderConfigsService.patchDocumentById(recordId, patch, {
+          context
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_provider_configs.delete",
+      version: 1,
+      kind: "command",
+      channels: ["api", "automation", "internal"],
+      surfaces: [surface],
+      permission: { require: "all", permissions: [actionPermissions.delete] },
+      input: composeSchemaDefinitions([
+  workspaceSlugParamsValidator,
+  recordIdParamsValidator,
+]),
+      output: null,
+      idempotency: "optional",
+      audit: {
+        actionName: "crud.google_rewarded_provider_configs.delete"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        return deps.googleRewardedProviderConfigsService.deleteDocumentById(input.recordId, {
+          context
+        });
+      }
+    }
+  ]);
+}
+
+export { createActions };