@jskit-ai/google-rewarded-core 0.1.1

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

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

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