@distilled.cloud/forgejo 0.0.0 → 1.0.0-rc.9

package/src/retry.ts

@@ -0,0 +1,74 @@
+/**
+ * Forgejo retry surface — a veneer over `@distilled.cloud/core/retry`.
+ *
+ * The `Retry` service tag is threaded into every generated operation via
+ * `API.make({ retry: Retry })`, so a caller-installed policy applies to all
+ * Forgejo calls below it and core's `makeDefault` is the fallback when none
+ * is provided.
+ *
+ * @example
+ * ```ts
+ * import * as Forgejo from "@distilled.cloud/forgejo";
+ *
+ * myEffect.pipe(Forgejo.Retry.transient);
+ * ```
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Retries from "@distilled.cloud/core/retry";
+
+export type Options = Retries.Options;
+export type Factory = Retries.Factory;
+export type Policy = Retries.Policy;
+
+/** Context tag for configuring retry behavior of Forgejo API calls. */
+export class Retry extends Context.Service<Retry, Policy>()("ForgejoRetry") {}
+
+/** Provides a custom retry policy to every Forgejo API call below it. */
+export const policy: {
+  (
+    options: Options,
+  ): <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, Exclude<R, Retry>>;
+  (
+    factory: Factory,
+  ): <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, Exclude<R, Retry>>;
+} = (optionsOrFactory: Options | Factory) =>
+  Effect.provide(Layer.succeed(Retry, optionsOrFactory));
+
+/** Disables all automatic retries. */
+export const none: <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, Retry>> = Effect.provide(
+  Layer.succeed(Retry, { while: () => false }),
+);
+
+/**
+ * The default retry policy (core's): transient/throttling/retryable errors,
+ * capped exponential backoff with jitter, server `retryAfter` hints honored
+ * with precedence.
+ */
+export const makeDefault: Factory = Retries.makeDefault;
+
+export const jittered = Retries.jittered;
+export const capped = Retries.capped;
+
+/** Retry options that retry all throttling errors indefinitely. */
+export const throttlingOptions: Options = Retries.throttlingOptions;
+
+/** Retries all throttling errors indefinitely (honoring server hints). */
+export const throttling: <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, Retry>> = policy(Retries.throttlingFactory);
+
+/** Retry options that retry all transient errors indefinitely. */
+export const transientOptions: Options = Retries.transientOptions;
+
+/** Retries all transient errors indefinitely (honoring server hints). */
+export const transient: <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, Retry>> = policy(Retries.transientFactory);

package/src/services/activitypub.ts

@@ -0,0 +1,415 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-forgejo). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  ForgejoProtocol,
+  type ForgejoOpError,
+  type ForgejoOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { ForgejoOpError, ForgejoOpContext };
+
+export class Forbidden
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withAuthError),
+    [{ status: 403 }],
+  ) {}
+
+export interface ActivitypubInstanceActorRequest {}
+export const ActivitypubInstanceActorRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/activitypub/actor", code: 200 }),
+  ),
+).annotate({
+  identifier: "ActivitypubInstanceActorRequest",
+}) as any as S.Schema<ActivitypubInstanceActorRequest>;
+
+/** ActivityPub type */
+export interface ActivityPub {
+  _context?: string;
+}
+export const ActivityPub = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    _context: S.optional(S.String.pipe(T.Body("@context"))),
+  }),
+).annotate({ identifier: "ActivityPub" }) as any as S.Schema<ActivityPub>;
+
+export interface ActivitypubInstanceActorInboxRequest {}
+export const ActivitypubInstanceActorInboxRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/activitypub/actor/inbox", code: 200 }),
+    ),
+).annotate({
+  identifier: "ActivitypubInstanceActorInboxRequest",
+}) as any as S.Schema<ActivitypubInstanceActorInboxRequest>;
+
+export interface ActivitypubInstanceActorInboxResponse {}
+export const ActivitypubInstanceActorInboxResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "ActivitypubInstanceActorInboxResponse",
+}) as any as S.Schema<ActivitypubInstanceActorInboxResponse>;
+
+export interface ActivitypubInstanceActorOutboxRequest {}
+export const ActivitypubInstanceActorOutboxRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/activitypub/actor/outbox", code: 200 }),
+    ),
+).annotate({
+  identifier: "ActivitypubInstanceActorOutboxRequest",
+}) as any as S.Schema<ActivitypubInstanceActorOutboxRequest>;
+
+export type ActivitypubInstanceActorOutboxResponse = unknown;
+export const ActivitypubInstanceActorOutboxResponse = /*@__PURE__*/ S.suspend(
+  () => S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ActivitypubInstanceActorOutboxResponse",
+}) as any as S.Schema<ActivitypubInstanceActorOutboxResponse>;
+
+export interface ActivitypubPersonRequest {
+  /** user ID of the user */
+  user_id: number;
+}
+export const ActivitypubPersonRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    user_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/activitypub/user-id/{user_id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "ActivitypubPersonRequest",
+}) as any as S.Schema<ActivitypubPersonRequest>;
+
+export interface ActivitypubPersonActivityRequest {
+  /** user ID of the user */
+  user_id: number;
+  /** activity ID of the sought activity */
+  activity_id: number;
+}
+export const ActivitypubPersonActivityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    user_id: S.Number.pipe(T.Label()),
+    activity_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/activitypub/user-id/{user_id}/activities/{activity_id}/activity",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ActivitypubPersonActivityRequest",
+}) as any as S.Schema<ActivitypubPersonActivityRequest>;
+
+export interface ActivitypubPersonActivityNoteRequest {
+  /** user ID of the user */
+  user_id: number;
+  /** activity ID of the sought activity */
+  activity_id: number;
+}
+export const ActivitypubPersonActivityNoteRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      user_id: S.Number.pipe(T.Label()),
+      activity_id: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/activitypub/user-id/{user_id}/activities/{activity_id}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ActivitypubPersonActivityNoteRequest",
+}) as any as S.Schema<ActivitypubPersonActivityNoteRequest>;
+
+export interface ActivitypubPersonFeedRequest {
+  /** user ID of the user */
+  user_id: number;
+}
+export const ActivitypubPersonFeedRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    user_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/activitypub/user-id/{user_id}/outbox",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ActivitypubPersonFeedRequest",
+}) as any as S.Schema<ActivitypubPersonFeedRequest>;
+
+export type ActivitypubPersonFeedResponse = unknown;
+export const ActivitypubPersonFeedResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ActivitypubPersonFeedResponse",
+}) as any as S.Schema<ActivitypubPersonFeedResponse>;
+
+export interface ActivitypubPersonInboxRequest {
+  /** user ID of the user */
+  user_id: number;
+}
+export const ActivitypubPersonInboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    user_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/activitypub/user-id/{user_id}/inbox",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ActivitypubPersonInboxRequest",
+}) as any as S.Schema<ActivitypubPersonInboxRequest>;
+
+export interface ActivitypubPersonInboxResponse {}
+export const ActivitypubPersonInboxResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ActivitypubPersonInboxResponse",
+}) as any as S.Schema<ActivitypubPersonInboxResponse>;
+
+export interface ActivitypubRepositoryRequest {
+  /** repository ID of the repo */
+  repository_id: number;
+}
+export const ActivitypubRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    repository_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/activitypub/repository-id/{repository_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ActivitypubRepositoryRequest",
+}) as any as S.Schema<ActivitypubRepositoryRequest>;
+
+export interface ActivitypubRepositoryInboxRequest {
+  /** repository ID of the repo */
+  repository_id: number;
+}
+export const ActivitypubRepositoryInboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    repository_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/activitypub/repository-id/{repository_id}/inbox",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ActivitypubRepositoryInboxRequest",
+}) as any as S.Schema<ActivitypubRepositoryInboxRequest>;
+
+export interface ActivitypubRepositoryInboxResponse {}
+export const ActivitypubRepositoryInboxResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ActivitypubRepositoryInboxResponse",
+}) as any as S.Schema<ActivitypubRepositoryInboxResponse>;
+
+export interface ActivitypubRepositoryOutboxRequest {
+  /** repository ID of the repo */
+  repository_id: number;
+}
+export const ActivitypubRepositoryOutboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    repository_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/activitypub/repository-id/{repository_id}/outbox",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ActivitypubRepositoryOutboxRequest",
+}) as any as S.Schema<ActivitypubRepositoryOutboxRequest>;
+
+export type ActivitypubRepositoryOutboxResponse = unknown;
+export const ActivitypubRepositoryOutboxResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ActivitypubRepositoryOutboxResponse",
+}) as any as S.Schema<ActivitypubRepositoryOutboxResponse>;
+
+export type ActivitypubInstanceActorError = ForgejoOpError;
+/** Returns the instance's Actor */
+export const activitypubInstanceActor: API.OperationMethod<
+  ActivitypubInstanceActorRequest,
+  ActivityPub,
+  ActivitypubInstanceActorError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubInstanceActorRequest,
+  output: ActivityPub,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubInstanceActorInboxError = ForgejoOpError;
+/** Send to the inbox */
+export const activitypubInstanceActorInbox: API.OperationMethod<
+  ActivitypubInstanceActorInboxRequest,
+  ActivitypubInstanceActorInboxResponse,
+  ActivitypubInstanceActorInboxError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubInstanceActorInboxRequest,
+  output: ActivitypubInstanceActorInboxResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubInstanceActorOutboxError = ForgejoOpError;
+/** Display the outbox (always empty) */
+export const activitypubInstanceActorOutbox: API.OperationMethod<
+  ActivitypubInstanceActorOutboxRequest,
+  ActivitypubInstanceActorOutboxResponse,
+  ActivitypubInstanceActorOutboxError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubInstanceActorOutboxRequest,
+  output: ActivitypubInstanceActorOutboxResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubPersonError = ForgejoOpError;
+/** Returns the Person actor for a user */
+export const activitypubPerson: API.OperationMethod<
+  ActivitypubPersonRequest,
+  ActivityPub,
+  ActivitypubPersonError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubPersonRequest,
+  output: ActivityPub,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubPersonActivityError = ForgejoOpError;
+/** Get a specific activity of the user */
+export const activitypubPersonActivity: API.OperationMethod<
+  ActivitypubPersonActivityRequest,
+  ActivityPub,
+  ActivitypubPersonActivityError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubPersonActivityRequest,
+  output: ActivityPub,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubPersonActivityNoteError = ForgejoOpError;
+/** Get a specific activity object of the user */
+export const activitypubPersonActivityNote: API.OperationMethod<
+  ActivitypubPersonActivityNoteRequest,
+  ActivityPub,
+  ActivitypubPersonActivityNoteError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubPersonActivityNoteRequest,
+  output: ActivityPub,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubPersonFeedError = Forbidden | ForgejoOpError;
+/** List the user's recorded activity */
+export const activitypubPersonFeed: API.OperationMethod<
+  ActivitypubPersonFeedRequest,
+  ActivitypubPersonFeedResponse,
+  ActivitypubPersonFeedError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubPersonFeedRequest,
+  output: ActivitypubPersonFeedResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubPersonInboxError = ForgejoOpError;
+/** Send to the inbox */
+export const activitypubPersonInbox: API.OperationMethod<
+  ActivitypubPersonInboxRequest,
+  ActivitypubPersonInboxResponse,
+  ActivitypubPersonInboxError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubPersonInboxRequest,
+  output: ActivitypubPersonInboxResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubRepositoryError = ForgejoOpError;
+/** Returns the Repository actor for a repo */
+export const activitypubRepository: API.OperationMethod<
+  ActivitypubRepositoryRequest,
+  ActivityPub,
+  ActivitypubRepositoryError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubRepositoryRequest,
+  output: ActivityPub,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubRepositoryInboxError = ForgejoOpError;
+/** Send to the inbox */
+export const activitypubRepositoryInbox: API.OperationMethod<
+  ActivitypubRepositoryInboxRequest,
+  ActivitypubRepositoryInboxResponse,
+  ActivitypubRepositoryInboxError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubRepositoryInboxRequest,
+  output: ActivitypubRepositoryInboxResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ActivitypubRepositoryOutboxError = ForgejoOpError;
+/** Display the outbox */
+export const activitypubRepositoryOutbox: API.OperationMethod<
+  ActivitypubRepositoryOutboxRequest,
+  ActivitypubRepositoryOutboxResponse,
+  ActivitypubRepositoryOutboxError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivitypubRepositoryOutboxRequest,
+  output: ActivitypubRepositoryOutboxResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));