@jskit-ai/google-rewarded-core 0.1.1

package/src/server/providerConfigs/registerRoutes.js

@@ -0,0 +1,176 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { createCrudJsonApiRouteContracts } from "@jskit-ai/crud-core/server/routeContracts";
+import { checkRouteVisibility } from "@jskit-ai/kernel/shared/support/visibility";
+import { resolveScopedApiBasePath } from "@jskit-ai/kernel/shared/surface";
+import { resource } from "../../shared/googleRewardedProviderConfigResource.js";
+import { routeParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
+import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/workspaces-core/server/support/workspaceRouteInput";
+
+const {
+  listRouteContract,
+  viewRouteContract,
+  createRouteContract,
+  updateRouteContract,
+  deleteRouteContract,
+  recordRouteParamsValidator
+} = createCrudJsonApiRouteContracts({
+  resource,
+  routeParamsValidator
+});
+
+function registerRoutes(
+  app,
+  {
+    routeOwnershipFilter = "public",
+    routeSurface = "",
+    routeRelativePath = ""
+  } = {}
+) {
+  const router = app.make("jskit.http.router");
+  const normalizedRouteSurface = normalizeSurfaceId(routeSurface);
+  const routeBase = resolveScopedApiBasePath({
+    routeBase: "/w/:workspaceSlug",
+    relativePath: routeRelativePath,
+    strictParams: false
+  });
+
+  router.register(
+    "GET",
+    routeBase,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      internal: true,
+      visibility: checkRouteVisibility(routeOwnershipFilter),
+      meta: {
+        tags: ["crud"],
+        summary: "List records."
+      },
+      ...listRouteContract,
+      params: routeParamsValidator,
+    },
+    async function (request, reply) {
+      const listInput = {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          ...(request.input.query || {})
+      };
+      const response = await request.executeAction({
+        actionId: "crud.google_rewarded_provider_configs.list",
+        input: listInput
+      });
+      reply.code(200).send(response);
+    }
+  );
+
+  router.register(
+    "GET",
+    `${routeBase}/:recordId`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      internal: true,
+      visibility: checkRouteVisibility(routeOwnershipFilter),
+      meta: {
+        tags: ["crud"],
+        summary: "View a record."
+      },
+      ...viewRouteContract,
+      params: recordRouteParamsValidator,
+    },
+    async function (request, reply) {
+      const response = await request.executeAction({
+        actionId: "crud.google_rewarded_provider_configs.view",
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          recordId: request.input.params.recordId,
+          ...(request.input.query || {})
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+
+  router.register(
+    "POST",
+    routeBase,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      internal: true,
+      visibility: checkRouteVisibility(routeOwnershipFilter),
+      meta: {
+        tags: ["crud"],
+        summary: "Create a record."
+      },
+      ...createRouteContract,
+      params: routeParamsValidator,
+    },
+    async function (request, reply) {
+      const response = await request.executeAction({
+        actionId: "crud.google_rewarded_provider_configs.create",
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          ...(request.input.body || {})
+        }
+      });
+      reply.code(201).send(response);
+    }
+  );
+
+  router.register(
+    "PATCH",
+    `${routeBase}/:recordId`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      internal: true,
+      visibility: checkRouteVisibility(routeOwnershipFilter),
+      meta: {
+        tags: ["crud"],
+        summary: "Update a record."
+      },
+      ...updateRouteContract,
+      params: recordRouteParamsValidator,
+    },
+    async function (request, reply) {
+      const response = await request.executeAction({
+        actionId: "crud.google_rewarded_provider_configs.update",
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          recordId: request.input.params.recordId,
+          ...(request.input.body || {})
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+
+  router.register(
+    "DELETE",
+    `${routeBase}/:recordId`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      internal: true,
+      visibility: checkRouteVisibility(routeOwnershipFilter),
+      meta: {
+        tags: ["crud"],
+        summary: "Delete a record."
+      },
+      ...deleteRouteContract,
+      params: recordRouteParamsValidator,
+    },
+    async function (request, reply) {
+      const response = await request.executeAction({
+        actionId: "crud.google_rewarded_provider_configs.delete",
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          recordId: request.input.params.recordId
+        }
+      });
+      reply.code(204).send(response);
+    }
+  );
+}
+
+export { registerRoutes };

package/src/server/providerConfigs/repository.js

@@ -0,0 +1,107 @@
+import { createWithTransaction } from "@jskit-ai/database-runtime/shared";
+import {
+  buildJsonRestQueryParams,
+  createJsonApiInputRecord,
+  createJsonRestContext,
+  returnNullWhenJsonRestResourceMissing
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { resource } from "../../shared/googleRewardedProviderConfigResource.js";
+const JSON_REST_SCOPE_NAME = "googleRewardedProviderConfigs";
+
+function createRepository({ api, knex } = {}) {
+  const withTransaction = createWithTransaction(knex);
+
+  async function queryDocuments(query = {}, options = {}) {
+    return api.resources.googleRewardedProviderConfigs.query(
+      {
+        queryParams: buildJsonRestQueryParams(JSON_REST_SCOPE_NAME, query),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+  }
+
+  async function getDocumentById(recordId, options = {}) {
+    return returnNullWhenJsonRestResourceMissing(() =>
+      api.resources.googleRewardedProviderConfigs.get(
+        {
+          id: recordId,
+          queryParams: buildJsonRestQueryParams(JSON_REST_SCOPE_NAME, {}, {
+            include: options?.include
+          }),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      )
+    );
+  }
+
+  async function createDocument(payload = {}, options = {}) {
+    return api.resources.googleRewardedProviderConfigs.post(
+      {
+        inputRecord: createJsonApiInputRecord(JSON_REST_SCOPE_NAME, payload, {
+          resource
+        }),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+  }
+
+  async function patchDocumentById(recordId, patch = {}, options = {}) {
+    const sourcePatch = patch && typeof patch === "object" && !Array.isArray(patch) ? patch : {};
+    if (Object.keys(sourcePatch).length < 1) {
+      return getDocumentById(recordId, options);
+    }
+
+    return returnNullWhenJsonRestResourceMissing(() =>
+      api.resources.googleRewardedProviderConfigs.patch(
+        {
+          id: recordId,
+          inputRecord: createJsonApiInputRecord(
+            JSON_REST_SCOPE_NAME,
+            {
+              ...sourcePatch,
+              updatedAt: new Date()
+            },
+            {
+              resource
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      )
+    );
+  }
+
+  async function deleteDocumentById(recordId, options = {}) {
+    return returnNullWhenJsonRestResourceMissing(async () => {
+      await api.resources.googleRewardedProviderConfigs.delete(
+        {
+          id: recordId,
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
+
+      return null;
+    });
+  }
+
+  return Object.freeze({
+    withTransaction,
+    queryDocuments,
+    getDocumentById,
+    createDocument,
+    patchDocumentById,
+    deleteDocumentById
+  });
+}
+
+export { createRepository };

package/src/server/providerConfigs/service.js

@@ -0,0 +1,61 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import { returnJsonApiDocument } from "@jskit-ai/http-runtime/shared";
+
+function return404IfNotFound(document = null) {
+  if (!document) {
+    throw new AppError(404, "Document not found.");
+  }
+  return document;
+}
+
+function createService({ googleRewardedProviderConfigsRepository } = {}) {
+  if (!googleRewardedProviderConfigsRepository) {
+    throw new TypeError("createService requires googleRewardedProviderConfigsRepository.");
+  }
+
+  async function queryDocuments(query = {}, options = {}) {
+    return returnJsonApiDocument(await googleRewardedProviderConfigsRepository.queryDocuments(query, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
+  }
+
+  async function getDocumentById(recordId, options = {}) {
+    return returnJsonApiDocument(return404IfNotFound(await googleRewardedProviderConfigsRepository.getDocumentById(recordId, {
+      trx: options?.trx || null,
+      context: options?.context || null,
+      include: options?.include
+    })));
+  }
+
+  async function createDocument(payload = {}, options = {}) {
+    return returnJsonApiDocument(await googleRewardedProviderConfigsRepository.createDocument(payload, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
+  }
+
+  async function patchDocumentById(recordId, payload = {}, options = {}) {
+    return returnJsonApiDocument(return404IfNotFound(await googleRewardedProviderConfigsRepository.patchDocumentById(recordId, payload, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    })));
+  }
+
+  async function deleteDocumentById(recordId, options = {}) {
+    return googleRewardedProviderConfigsRepository.deleteDocumentById(recordId, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    });
+  }
+
+  return Object.freeze({
+    queryDocuments,
+    getDocumentById,
+    createDocument,
+    patchDocumentById,
+    deleteDocumentById
+  });
+}
+
+export { createService };

package/src/server/registerRoutes.js

@@ -0,0 +1,169 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { checkRouteVisibility } from "@jskit-ai/kernel/shared/support/visibility";
+import { resolveScopedApiBasePath } from "@jskit-ai/kernel/shared/surface";
+import {
+  createTransportResponseSchema,
+  withStandardErrorResponses
+} from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+import { routeParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
+import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/workspaces-core/server/support/workspaceRouteInput";
+import {
+  ACTION_CURRENT,
+  ACTION_START,
+  ACTION_GRANT,
+  ACTION_CLOSE
+} from "./actions.js";
+import {
+  currentQueryInputValidator,
+  startCommandInputValidator,
+  grantCommandInputValidator,
+  closeCommandInputValidator,
+  currentStateOutputValidator,
+  startGateOutputValidator,
+  grantRewardOutputValidator,
+  closeSessionOutputValidator
+} from "./inputSchemas.js";
+
+function createWorkflowResponses(outputValidator) {
+  return withStandardErrorResponses({
+    200: createTransportResponseSchema(
+      outputValidator.schema.toJsonSchema({
+        mode: outputValidator.mode
+      })
+    )
+  }, {
+    includeValidation400: true
+  });
+}
+
+function registerRoutes(
+  app,
+  {
+    routeOwnershipFilter = "workspace_user",
+    routeSurface = "app",
+    routeRelativePath = "google-rewarded"
+  } = {}
+) {
+  if (!app || typeof app.make !== "function") {
+    throw new Error("registerRoutes requires application make().");
+  }
+
+  const router = app.make("jskit.http.router");
+  const normalizedRouteSurface = normalizeSurfaceId(routeSurface);
+  const routeBase = resolveScopedApiBasePath({
+    routeBase: "/w/:workspaceSlug",
+    relativePath: routeRelativePath,
+    strictParams: false
+  });
+  const visibility = checkRouteVisibility(routeOwnershipFilter);
+
+  router.register(
+    "GET",
+    `${routeBase}/current`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      visibility,
+      params: routeParamsValidator,
+      query: currentQueryInputValidator,
+      responses: createWorkflowResponses(currentStateOutputValidator),
+      meta: {
+        tags: ["google-rewarded"],
+        summary: "Read the current Google rewarded gate state."
+      }
+    },
+    async function googleRewardedCurrentRoute(request, reply) {
+      const response = await request.executeAction({
+        actionId: ACTION_CURRENT,
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          ...(request.input.query || {})
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+
+  router.register(
+    "POST",
+    `${routeBase}/start`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      visibility,
+      params: routeParamsValidator,
+      body: startCommandInputValidator,
+      responses: createWorkflowResponses(startGateOutputValidator),
+      meta: {
+        tags: ["google-rewarded"],
+        summary: "Start a Google rewarded watch session."
+      }
+    },
+    async function googleRewardedStartRoute(request, reply) {
+      const response = await request.executeAction({
+        actionId: ACTION_START,
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          ...(request.input.body || {})
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+
+  router.register(
+    "POST",
+    `${routeBase}/grant`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      visibility,
+      params: routeParamsValidator,
+      body: grantCommandInputValidator,
+      responses: createWorkflowResponses(grantRewardOutputValidator),
+      meta: {
+        tags: ["google-rewarded"],
+        summary: "Grant a Google rewarded unlock after a rewarded ad completes."
+      }
+    },
+    async function googleRewardedGrantRoute(request, reply) {
+      const response = await request.executeAction({
+        actionId: ACTION_GRANT,
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          ...(request.input.body || {})
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+
+  router.register(
+    "POST",
+    `${routeBase}/close`,
+    {
+      auth: "required",
+      surface: normalizedRouteSurface,
+      visibility,
+      params: routeParamsValidator,
+      body: closeCommandInputValidator,
+      responses: createWorkflowResponses(closeSessionOutputValidator),
+      meta: {
+        tags: ["google-rewarded"],
+        summary: "Close a Google rewarded watch session without granting a reward."
+      }
+    },
+    async function googleRewardedCloseRoute(request, reply) {
+      const response = await request.executeAction({
+        actionId: ACTION_CLOSE,
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          ...(request.input.body || {})
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+}
+
+export { registerRoutes };

package/src/server/rules/GoogleRewardedRulesProvider.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/googleRewardedRuleResource.js";
+const CRUD_MODULE_CONFIG = Object.freeze({
+  namespace: "google_rewarded_rules",
+  surface: "admin",
+  ownershipFilter: "workspace",
+  relativePath: "/google-rewarded-rules"
+});
+const baseServiceEvents = createCrudJsonApiServiceEvents(CRUD_MODULE_CONFIG.namespace);
+const serviceEvents = {
+  ...baseServiceEvents
+};
+
+function resolveCrudPolicyFromApp(app) {
+  return resolveCrudSurfacePolicyFromAppConfig(CRUD_MODULE_CONFIG, resolveAppConfig(app), {
+    context: "GoogleRewardedRulesProvider"
+  });
+}
+
+class GoogleRewardedRulesProvider {
+  static id = "crud.google_rewarded_rules";
+
+  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_rules", (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_rules",
+      (scope) => {
+        return createService({
+          googleRewardedRulesRepository: scope.make("repository.google_rewarded_rules")
+        });
+      },
+      {
+        events: serviceEvents
+      }
+    );
+
+    app.actions(
+      withActionDefaults(
+        createActions({
+          surface: crudPolicy.surfaceId
+        }),
+        {
+          domain: "crud",
+          dependencies: {
+            googleRewardedRulesService: "crud.google_rewarded_rules"
+          }
+        }
+      )
+    );
+  }
+
+  async boot(app) {
+    const crudPolicy = resolveCrudPolicyFromApp(app);
+    const api = app.make(INTERNAL_JSON_REST_API);
+    await addResourceIfMissing(
+      api,
+      "googleRewardedRules",
+      createJsonRestResourceScopeOptions(resource, {
+        writeSerializers: {
+          "datetime-utc": toDatabaseDateTimeUtc
+        }
+      })
+    );
+    registerRoutes(app, {
+      routeOwnershipFilter: crudPolicy.ownershipFilter,
+      routeSurface: crudPolicy.surfaceId,
+      routeSurfaceRequiresWorkspace: crudPolicy.surfaceDefinition.requiresWorkspace === true,
+      routeRelativePath: crudPolicy.relativePath
+    });
+  }
+}
+
+export { GoogleRewardedRulesProvider };