@jskit-ai/google-rewarded-core 0.1.1

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

package/src/server/unlockReceipts/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/googleRewardedUnlockReceiptResource.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_unlock_receipts.list",
+  view: "crud.google_rewarded_unlock_receipts.view",
+  create: "crud.google_rewarded_unlock_receipts.create",
+  update: "crud.google_rewarded_unlock_receipts.update",
+  delete: "crud.google_rewarded_unlock_receipts.delete"
+});
+
+function createActions({ surface } = {}) {
+  return Object.freeze([
+    {
+      id: "crud.google_rewarded_unlock_receipts.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_unlock_receipts.list"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        const { workspaceSlug, ...query } = input || {};
+        return deps.googleRewardedUnlockReceiptsService.queryDocuments(query, {
+          context
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_unlock_receipts.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_unlock_receipts.view"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        return deps.googleRewardedUnlockReceiptsService.getDocumentById(input.recordId, {
+          context,
+          include: input.include
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_unlock_receipts.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_unlock_receipts.create"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        const { workspaceSlug, ...payload } = input || {};
+        return deps.googleRewardedUnlockReceiptsService.createDocument(payload, {
+          context
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_unlock_receipts.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_unlock_receipts.update"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        const { workspaceSlug, recordId, ...patch } = input || {};
+        return deps.googleRewardedUnlockReceiptsService.patchDocumentById(recordId, patch, {
+          context
+        });
+      }
+    },
+    {
+      id: "crud.google_rewarded_unlock_receipts.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_unlock_receipts.delete"
+      },
+      observability: {},
+      async execute(input, context, deps) {
+        return deps.googleRewardedUnlockReceiptsService.deleteDocumentById(input.recordId, {
+          context
+        });
+      }
+    }
+  ]);
+}
+
+export { createActions };

package/src/server/unlockReceipts/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/googleRewardedUnlockReceiptResource.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_unlock_receipts.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_unlock_receipts.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_unlock_receipts.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_unlock_receipts.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_unlock_receipts.delete",
+        input: {
+          ...buildWorkspaceInputFromRouteParams(request.input.params),
+          recordId: request.input.params.recordId
+        }
+      });
+      reply.code(204).send(response);
+    }
+  );
+}
+
+export { registerRoutes };

package/src/server/unlockReceipts/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/googleRewardedUnlockReceiptResource.js";
+const JSON_REST_SCOPE_NAME = "googleRewardedUnlockReceipts";
+
+function createRepository({ api, knex } = {}) {
+  const withTransaction = createWithTransaction(knex);
+
+  async function queryDocuments(query = {}, options = {}) {
+    return api.resources.googleRewardedUnlockReceipts.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.googleRewardedUnlockReceipts.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.googleRewardedUnlockReceipts.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.googleRewardedUnlockReceipts.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.googleRewardedUnlockReceipts.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/unlockReceipts/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({ googleRewardedUnlockReceiptsRepository } = {}) {
+  if (!googleRewardedUnlockReceiptsRepository) {
+    throw new TypeError("createService requires googleRewardedUnlockReceiptsRepository.");
+  }
+
+  async function queryDocuments(query = {}, options = {}) {
+    return returnJsonApiDocument(await googleRewardedUnlockReceiptsRepository.queryDocuments(query, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
+  }
+
+  async function getDocumentById(recordId, options = {}) {
+    return returnJsonApiDocument(return404IfNotFound(await googleRewardedUnlockReceiptsRepository.getDocumentById(recordId, {
+      trx: options?.trx || null,
+      context: options?.context || null,
+      include: options?.include
+    })));
+  }
+
+  async function createDocument(payload = {}, options = {}) {
+    return returnJsonApiDocument(await googleRewardedUnlockReceiptsRepository.createDocument(payload, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    }));
+  }
+
+  async function patchDocumentById(recordId, payload = {}, options = {}) {
+    return returnJsonApiDocument(return404IfNotFound(await googleRewardedUnlockReceiptsRepository.patchDocumentById(recordId, payload, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    })));
+  }
+
+  async function deleteDocumentById(recordId, options = {}) {
+    return googleRewardedUnlockReceiptsRepository.deleteDocumentById(recordId, {
+      trx: options?.trx || null,
+      context: options?.context || null
+    });
+  }
+
+  return Object.freeze({
+    queryDocuments,
+    getDocumentById,
+    createDocument,
+    patchDocumentById,
+    deleteDocumentById
+  });
+}
+
+export { createService };

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