@computis/effect-github 0.0.0-stage → 0.1.0

package/src/action-client.ts

@@ -0,0 +1,238 @@
+import { getOctokit } from "@actions/github";
+import { GitHub } from "@actions/github/lib/utils";
+import { whenDefined } from "./object.ts";
+import { thrownMessage } from "./thrown-message.ts";
+import { Config, Context, Effect, flow, Layer, Option, Redacted, Schema, Stream } from "effect";
+import { ActionApiError } from "./errors/action-api-error.ts";
+
+export type Octokit = ReturnType<typeof getOctokit>;
+
+export type OctokitOptions = NonNullable<Parameters<typeof getOctokit>[1]>;
+
+export type RequestParameters = Readonly<Record<string, Schema.Json>>;
+
+export type RestResponse = Omit<Awaited<ReturnType<Octokit["request"]>>, "data"> & {
+  readonly data: Schema.Json;
+};
+
+export interface PaginateOptions {
+  readonly maxPages?: number;
+}
+
+export interface ActionClientApi {
+  readonly octokit: Octokit;
+  readonly call: <A>(
+    method: string,
+    run: (octokit: Octokit) => Promise<A>,
+  ) => Effect.Effect<A, ActionApiError>;
+  readonly request: (
+    route: string,
+    parameters?: RequestParameters,
+  ) => Effect.Effect<RestResponse, ActionApiError>;
+  readonly graphql: (
+    query: string,
+    variables?: RequestParameters,
+  ) => Effect.Effect<Schema.Json, ActionApiError>;
+  readonly paginate: (
+    route: string,
+    parameters?: RequestParameters,
+    options?: PaginateOptions,
+  ) => Effect.Effect<readonly Schema.Json[], ActionApiError>;
+  readonly requestDecoded: <S extends Schema.Top>(
+    schema: S,
+    route: string,
+    parameters?: RequestParameters,
+  ) => Effect.Effect<S["Type"], ActionApiError, S["DecodingServices"]>;
+  readonly graphqlDecoded: <S extends Schema.Top>(
+    schema: S,
+    query: string,
+    variables?: RequestParameters,
+  ) => Effect.Effect<S["Type"], ActionApiError, S["DecodingServices"]>;
+  readonly paginateDecoded: <S extends Schema.Top>(
+    schema: S,
+    route: string,
+    parameters?: RequestParameters,
+    options?: PaginateOptions,
+  ) => Effect.Effect<readonly S["Type"][], ActionApiError, S["DecodingServices"]>;
+}
+
+const defaultMaxPages = 100;
+
+const decodeMaxPages = Schema.decodeUnknownEffect(
+  Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+);
+
+const decodeHttpStatus = Schema.decodeUnknownOption(Schema.Struct({ status: Schema.Number }));
+
+const decodeResponse = <S extends Schema.Top>(schema: S, method: string) =>
+  flow(
+    Schema.decodeUnknownEffect(schema),
+    Effect.mapError(
+      (cause) =>
+        new ActionApiError({ cause, description: `unexpected response: ${cause.message}`, method }),
+    ),
+  );
+
+const requestFailed = (method: string) => (cause: unknown) =>
+  cause instanceof ActionApiError
+    ? cause
+    : new ActionApiError({
+        cause,
+        description: thrownMessage(cause, "the request failed"),
+        method,
+        ...whenDefined(Option.getOrUndefined(decodeHttpStatus(cause)), ({ status }) => ({
+          status,
+        })),
+      });
+
+const make = (token: Redacted.Redacted, options: OctokitOptions = {}): ActionClientApi => {
+  const secret = Redacted.value(token);
+  const octokit = secret === "" ? new GitHub(options) : getOctokit(secret, options);
+  const call = Effect.fn("ActionClient.call")(function* call<A>(
+    method: string,
+    run: (client: Octokit) => Promise<A>,
+  ) {
+    return yield* Effect.tryPromise({
+      catch: requestFailed(method),
+      try: async () => await run(octokit),
+    });
+  });
+  const request = Effect.fn("ActionClient.request")(function* request(
+    route: string,
+    parameters?: RequestParameters,
+  ) {
+    const response = yield* call(route, async (client) => await client.request(route, parameters));
+    const data = yield* decodeResponse(Schema.Json, route)(response.data);
+    const restResponse: RestResponse = { ...response, data };
+    return restResponse;
+  });
+  const graphql = Effect.fn("ActionClient.graphql")(function* graphql(
+    query: string,
+    variables?: RequestParameters,
+  ) {
+    const data = yield* call("graphql", async (client) => await client.graphql(query, variables));
+    return yield* decodeResponse(Schema.Json, "graphql")(data);
+  });
+  const paginate = Effect.fn("ActionClient.paginate")(function* paginate(
+    route: string,
+    parameters?: RequestParameters,
+    paginateOptions: PaginateOptions = {},
+  ) {
+    const maxPages = yield* decodeMaxPages(paginateOptions.maxPages ?? defaultMaxPages).pipe(
+      Effect.mapError(
+        (cause) =>
+          new ActionApiError({
+            cause,
+            description: `maxPages must be a positive integer: ${cause.message}`,
+            method: route,
+          }),
+      ),
+    );
+    const iterator = yield* Effect.try({
+      catch: requestFailed(route),
+      try: () => octokit.paginate.iterator(route, parameters),
+    });
+    const pages = yield* Stream.fromAsyncIterable(iterator, requestFailed(route)).pipe(
+      Stream.take(maxPages + 1),
+      Stream.runCollect,
+    );
+    if (pages.length > maxPages) {
+      return yield* new ActionApiError({
+        description: `more than ${maxPages} pages`,
+        method: route,
+      });
+    }
+    return yield* decodeResponse(
+      Schema.Array(Schema.Json),
+      route,
+    )(pages.flatMap((page) => page.data));
+  });
+  return {
+    call,
+    graphql,
+    graphqlDecoded: Effect.fn("ActionClient.graphqlDecoded")(function* graphqlDecoded<
+      S extends Schema.Top,
+    >(schema: S, query: string, variables?: RequestParameters) {
+      const data = yield* graphql(query, variables);
+      return yield* decodeResponse(schema, "graphql")(data);
+    }),
+    octokit,
+    paginate,
+    paginateDecoded: Effect.fn("ActionClient.paginateDecoded")(function* paginateDecoded<
+      S extends Schema.Top,
+    >(schema: S, route: string, parameters?: RequestParameters, paginateOptions?: PaginateOptions) {
+      const items = yield* paginate(route, parameters, paginateOptions);
+      return yield* decodeResponse(Schema.Array(schema), route)(items);
+    }),
+    request,
+    requestDecoded: Effect.fn("ActionClient.requestDecoded")(function* requestDecoded<
+      S extends Schema.Top,
+    >(schema: S, route: string, parameters?: RequestParameters) {
+      const { data } = yield* request(route, parameters);
+      return yield* decodeResponse(schema, route)(data);
+    }),
+  };
+};
+
+export class ActionClient extends Context.Service<ActionClient, ActionClientApi>()(
+  "@computis/effect-github/ActionClient",
+) {
+  static readonly layer = (token: Redacted.Redacted, options?: OctokitOptions) =>
+    Layer.sync(ActionClient, () => make(token, options));
+
+  static readonly layerConfig = Layer.effect(
+    ActionClient,
+    Effect.gen(function* makeActionClientFromConfig() {
+      const token = yield* Config.Redacted("INPUT_GITHUB_TOKEN").pipe(
+        Config.orElse(() => Config.Redacted("GITHUB_TOKEN")),
+        Config.withDefault(Redacted.make("")),
+      );
+      return make(token);
+    }),
+  );
+}
+
+const client = Effect.service(ActionClient);
+
+export const octokit: Effect.Effect<Octokit, never, ActionClient> = client.pipe(
+  Effect.map((service) => service.octokit),
+);
+
+export const request = (route: string, parameters?: RequestParameters) =>
+  client.pipe(Effect.flatMap((service) => service.request(route, parameters)));
+
+export const graphql = (query: string, variables?: RequestParameters) =>
+  client.pipe(Effect.flatMap((service) => service.graphql(query, variables)));
+
+export const paginate = (
+  route: string,
+  parameters?: RequestParameters,
+  options?: PaginateOptions,
+) => client.pipe(Effect.flatMap((service) => service.paginate(route, parameters, options)));
+
+export const { layer, layerConfig } = ActionClient;
+
+export const call = <A>(method: string, run: (octokit: Octokit) => Promise<A>) =>
+  client.pipe(Effect.flatMap((service) => service.call(method, run)));
+
+export const requestDecoded = <S extends Schema.Top>(
+  schema: S,
+  route: string,
+  parameters?: RequestParameters,
+) => client.pipe(Effect.flatMap((service) => service.requestDecoded(schema, route, parameters)));
+
+export const graphqlDecoded = <S extends Schema.Top>(
+  schema: S,
+  query: string,
+  variables?: RequestParameters,
+) => client.pipe(Effect.flatMap((service) => service.graphqlDecoded(schema, query, variables)));
+
+export const paginateDecoded = <S extends Schema.Top>(
+  schema: S,
+  route: string,
+  parameters?: RequestParameters,
+  options?: PaginateOptions,
+) =>
+  client.pipe(
+    Effect.flatMap((service) => service.paginateDecoded(schema, route, parameters, options)),
+  );

package/src/action-context.ts

@@ -0,0 +1,121 @@
+import { context } from "@actions/github";
+import { thrownMessage } from "./thrown-message.ts";
+import { Context, Effect, Layer, Schema } from "effect";
+import { ActionContextError, ActionContextErrorReason } from "./errors/action-context-error.ts";
+
+export interface RepoContext {
+  readonly owner: string;
+  readonly repo: string;
+}
+
+export interface IssueContext extends RepoContext {
+  readonly number: number;
+}
+
+export interface ActionContextApi {
+  readonly eventName: string;
+  readonly payload: unknown;
+  readonly workflow: string;
+  readonly action: string;
+  readonly actor: string;
+  readonly job: string;
+  readonly runId: number;
+  readonly runNumber: number;
+  readonly runAttempt: number;
+  readonly ref: string;
+  readonly sha: string;
+  readonly apiUrl: string;
+  readonly serverUrl: string;
+  readonly graphqlUrl: string;
+  readonly repo: Effect.Effect<RepoContext, ActionContextError>;
+  readonly issue: Effect.Effect<IssueContext, ActionContextError>;
+}
+
+const readRepository = Effect.fn("ActionContext.readRepository")(function* readRepository<A>(
+  read: () => A,
+) {
+  return yield* Effect.try({
+    catch: (cause) =>
+      new ActionContextError({
+        cause,
+        description: thrownMessage(cause, "GITHUB_REPOSITORY is not set"),
+        reason: ActionContextErrorReason.InvalidRepo,
+      }),
+    try: read,
+  });
+});
+
+export class ActionContext extends Context.Service<ActionContext, ActionContextApi>()(
+  "@computis/effect-github/ActionContext",
+) {
+  static readonly layer = Layer.sync(ActionContext, () => ({
+    action: context.action,
+    actor: context.actor,
+    apiUrl: context.apiUrl,
+    eventName: context.eventName,
+    graphqlUrl: context.graphqlUrl,
+    issue: readRepository(() => context.issue),
+    job: context.job,
+    payload: context.payload,
+    ref: context.ref,
+    repo: readRepository(() => context.repo),
+    runAttempt: context.runAttempt,
+    runId: context.runId,
+    runNumber: context.runNumber,
+    serverUrl: context.serverUrl,
+    sha: context.sha,
+    workflow: context.workflow,
+  }));
+}
+
+export const decodePayload = Effect.fn("ActionContext.decodePayload")(function* decodePayload<
+  S extends Schema.Top,
+>(schema: S) {
+  const current = yield* ActionContext;
+  return yield* Schema.decodeUnknownEffect(schema)(current.payload).pipe(
+    Effect.mapError(
+      (cause) =>
+        new ActionContextError({
+          cause,
+          description: `The ${current.eventName} payload does not match: ${cause.message}`,
+          reason: ActionContextErrorReason.InvalidPayload,
+        }),
+    ),
+  );
+});
+
+const actionContext = Effect.service(ActionContext);
+
+export const eventName = actionContext.pipe(Effect.map((current) => current.eventName));
+
+export const payload = actionContext.pipe(Effect.map((current) => current.payload));
+
+export const workflow = actionContext.pipe(Effect.map((current) => current.workflow));
+
+export const action = actionContext.pipe(Effect.map((current) => current.action));
+
+export const actor = actionContext.pipe(Effect.map((current) => current.actor));
+
+export const job = actionContext.pipe(Effect.map((current) => current.job));
+
+export const runId = actionContext.pipe(Effect.map((current) => current.runId));
+
+export const runNumber = actionContext.pipe(Effect.map((current) => current.runNumber));
+
+export const runAttempt = actionContext.pipe(Effect.map((current) => current.runAttempt));
+
+export const ref = actionContext.pipe(Effect.map((current) => current.ref));
+
+export const sha = actionContext.pipe(Effect.map((current) => current.sha));
+
+export const apiUrl = actionContext.pipe(Effect.map((current) => current.apiUrl));
+
+export const serverUrl = actionContext.pipe(Effect.map((current) => current.serverUrl));
+
+export const graphqlUrl = actionContext.pipe(Effect.map((current) => current.graphqlUrl));
+
+export const repo = actionContext.pipe(Effect.flatMap((current) => current.repo));
+
+export const issue = actionContext.pipe(Effect.flatMap((current) => current.issue));
+
+export const { layer } = ActionContext;

package/src/action-runner.ts

@@ -0,0 +1,221 @@
+import * as core from "@actions/core";
+import { thrownMessage } from "./thrown-message.ts";
+import { Context, Effect, Layer, Redacted } from "effect";
+import type { Schema } from "effect";
+import { ActionInputError, ActionInputErrorReason } from "./errors/action-input-error.ts";
+import { ActionOIDCError, ActionOIDCErrorReason } from "./errors/action-oidc-error.ts";
+
+export interface InputOptions {
+  readonly required?: boolean;
+  readonly trimWhitespace?: boolean;
+}
+
+export type AnnotationProperties = core.AnnotationProperties;
+
+export interface ActionRunnerApi {
+  readonly getInput: (
+    name: string,
+    options?: InputOptions,
+  ) => Effect.Effect<string, ActionInputError>;
+  readonly getMultilineInput: (
+    name: string,
+    options?: InputOptions,
+  ) => Effect.Effect<readonly string[], ActionInputError>;
+  readonly getBooleanInput: (
+    name: string,
+    options?: InputOptions,
+  ) => Effect.Effect<boolean, ActionInputError>;
+  readonly setOutput: (name: string, value: Schema.Json) => Effect.Effect<void>;
+  readonly debug: (message: string) => Effect.Effect<void>;
+  readonly info: (message: string) => Effect.Effect<void>;
+  readonly warning: (
+    message: string | Error,
+    properties?: AnnotationProperties,
+  ) => Effect.Effect<void>;
+  readonly error: (
+    message: string | Error,
+    properties?: AnnotationProperties,
+  ) => Effect.Effect<void>;
+  readonly notice: (
+    message: string | Error,
+    properties?: AnnotationProperties,
+  ) => Effect.Effect<void>;
+  readonly startGroup: (name: string) => Effect.Effect<void>;
+  readonly endGroup: () => Effect.Effect<void>;
+  readonly group: <A, E, R>(
+    name: string,
+    fn: () => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, R>;
+  readonly exportVariable: (name: string, value: string) => Effect.Effect<void>;
+  readonly addPath: (path: string) => Effect.Effect<void>;
+  readonly setSecret: (secret: string) => Effect.Effect<void>;
+  readonly saveState: (name: string, value: Schema.Json) => Effect.Effect<void>;
+  readonly getState: (name: string) => Effect.Effect<string>;
+  readonly setFailed: (message: string | Error) => Effect.Effect<void>;
+  readonly getIDToken: (audience?: string) => Effect.Effect<Redacted.Redacted, ActionOIDCError>;
+}
+
+const readInput = Effect.fn("ActionRunner.readInput")(function* readInput<A>(
+  name: string,
+  read: () => A,
+) {
+  return yield* Effect.try({
+    catch: (cause) => new ActionInputError({ cause, name, reason: ActionInputErrorReason.Missing }),
+    try: read,
+  });
+});
+
+export class ActionRunner extends Context.Service<ActionRunner, ActionRunnerApi>()(
+  "@computis/effect-github/ActionRunner",
+) {
+  static readonly layer = Layer.succeed(ActionRunner, {
+    addPath: (path) =>
+      Effect.sync(() => {
+        core.addPath(path);
+      }),
+    debug: (message) =>
+      Effect.sync(() => {
+        core.debug(message);
+      }),
+    endGroup: () =>
+      Effect.sync(() => {
+        core.endGroup();
+      }),
+    error: (message, properties) =>
+      Effect.sync(() => {
+        core.error(message, properties);
+      }),
+    exportVariable: (name, value) =>
+      Effect.sync(() => {
+        core.exportVariable(name, value);
+      }),
+    getBooleanInput: Effect.fn("ActionRunner.getBooleanInput")(function* getBooleanInput(
+      name: string,
+      options?: InputOptions,
+    ) {
+      return yield* Effect.try({
+        catch: (cause) =>
+          new ActionInputError({ cause, name, reason: ActionInputErrorReason.InvalidType }),
+        try: () => core.getBooleanInput(name, options),
+      });
+    }),
+    getIDToken: Effect.fn("ActionRunner.getIDToken")(function* getIDToken(audience?: string) {
+      return yield* Effect.tryPromise({
+        catch: (cause) =>
+          new ActionOIDCError({
+            cause,
+            description: thrownMessage(cause, "the token request was rejected"),
+            reason: ActionOIDCErrorReason.RequestFailed,
+          }),
+        try: async () => Redacted.make(await core.getIDToken(audience)),
+      });
+    }),
+    getInput: (name, options) => readInput(name, () => core.getInput(name, options)),
+    getMultilineInput: (name, options) =>
+      readInput(name, () => core.getMultilineInput(name, options)),
+    getState: (name) => Effect.sync(() => core.getState(name)),
+    group: <A, E, R>(name: string, fn: () => Effect.Effect<A, E, R>) =>
+      Effect.acquireUseRelease(
+        Effect.sync(() => {
+          core.startGroup(name);
+        }),
+        fn,
+        () =>
+          Effect.sync(() => {
+            core.endGroup();
+          }),
+      ).pipe(Effect.withSpan("ActionRunner.group", { attributes: { group: name } })),
+    info: (message) =>
+      Effect.sync(() => {
+        core.info(message);
+      }),
+    notice: (message, properties) =>
+      Effect.sync(() => {
+        core.notice(message, properties);
+      }),
+    saveState: (name, value) =>
+      Effect.sync(() => {
+        core.saveState(name, value);
+      }),
+    setFailed: (message) =>
+      Effect.sync(() => {
+        core.setFailed(message);
+      }),
+    setOutput: (name, value) =>
+      Effect.sync(() => {
+        core.setOutput(name, value);
+      }),
+    setSecret: (secret) =>
+      Effect.sync(() => {
+        core.setSecret(secret);
+      }),
+    startGroup: (name) =>
+      Effect.sync(() => {
+        core.startGroup(name);
+      }),
+    warning: (message, properties) =>
+      Effect.sync(() => {
+        core.warning(message, properties);
+      }),
+  });
+}
+
+const runner = Effect.service(ActionRunner);
+
+export const getInput = (name: string, options?: InputOptions) =>
+  runner.pipe(Effect.flatMap((service) => service.getInput(name, options)));
+
+export const getMultilineInput = (name: string, options?: InputOptions) =>
+  runner.pipe(Effect.flatMap((service) => service.getMultilineInput(name, options)));
+
+export const getBooleanInput = (name: string, options?: InputOptions) =>
+  runner.pipe(Effect.flatMap((service) => service.getBooleanInput(name, options)));
+
+export const setOutput = (name: string, value: Schema.Json) =>
+  runner.pipe(Effect.flatMap((service) => service.setOutput(name, value)));
+
+export const debug = (message: string) =>
+  runner.pipe(Effect.flatMap((service) => service.debug(message)));
+
+export const info = (message: string) =>
+  runner.pipe(Effect.flatMap((service) => service.info(message)));
+
+export const warning = (message: string | Error, properties?: AnnotationProperties) =>
+  runner.pipe(Effect.flatMap((service) => service.warning(message, properties)));
+
+export const error = (message: string | Error, properties?: AnnotationProperties) =>
+  runner.pipe(Effect.flatMap((service) => service.error(message, properties)));
+
+export const notice = (message: string | Error, properties?: AnnotationProperties) =>
+  runner.pipe(Effect.flatMap((service) => service.notice(message, properties)));
+
+export const startGroup = (name: string) =>
+  runner.pipe(Effect.flatMap((service) => service.startGroup(name)));
+
+export const endGroup = runner.pipe(Effect.flatMap((service) => service.endGroup()));
+
+export const group = <A, E, R>(name: string, fn: () => Effect.Effect<A, E, R>) =>
+  runner.pipe(Effect.flatMap((service) => service.group(name, fn)));
+
+export const exportVariable = (name: string, value: string) =>
+  runner.pipe(Effect.flatMap((service) => service.exportVariable(name, value)));
+
+export const addPath = (path: string) =>
+  runner.pipe(Effect.flatMap((service) => service.addPath(path)));
+
+export const setSecret = (secret: string) =>
+  runner.pipe(Effect.flatMap((service) => service.setSecret(secret)));
+
+export const saveState = (name: string, value: Schema.Json) =>
+  runner.pipe(Effect.flatMap((service) => service.saveState(name, value)));
+
+export const getState = (name: string) =>
+  runner.pipe(Effect.flatMap((service) => service.getState(name)));
+
+export const setFailed = (message: string | Error) =>
+  runner.pipe(Effect.flatMap((service) => service.setFailed(message)));
+
+export const getIDToken = (audience?: string) =>
+  runner.pipe(Effect.flatMap((service) => service.getIDToken(audience)));
+
+export const { layer } = ActionRunner;