@homeflare/alchemy 0.1.0

package/dist/forgejo/client.d.ts

@@ -0,0 +1,37 @@
+/**
+ * One authenticated call to the Forgejo (Gitea) API at `/api/v1`.
+ *
+ * ★ PLAIN `fetch`, NO TLS ESCAPE HATCH — your Forgejo host serves a real certificate on :443,
+ *   and the local daemon on :3000 is loopback. There is no `rejectUnauthorized` switch to leave
+ *   on by accident elsewhere.
+ *
+ * ⚠️ GITEA DOES NOT WRAP ANSWERS IN `{"data": ...}` THE WAY PVE DOES. MEASURED 2026-09-13 on
+ *   the live daemon: `GET /api/v1/version` returns `{"version":"16.0.3"}`; `GET /api/v1/user`
+ *   returns the user object; `GET /api/v1/orgs/HomeFlare/repos` returns a JSON array. A caller
+ *   that unwraps a non-existent envelope sees `undefined` and calls a healthy object "absent".
+ *
+ * ⛔ THE TOKEN IS NEVER A PROP. Read `FORGEJO_TOKEN` from the environment at call time only.
+ *   Alchemy persists attributes unencrypted and this estate's state store is Postgres dumped
+ *   nightly — nothing stored may be a credential.
+ */
+import * as Effect from 'effect/Effect';
+import * as HttpClient from 'effect/unstable/http/HttpClient';
+/**
+ * The Forgejo instance, from `FORGEJO_URL`. Trailing slash stripped.
+ *
+ * ⛔ NO DEFAULT HOSTNAME. This used to fall back to the author's own instance, which is
+ *   fine inside one estate and wrong in a published package: a consumer who forgets the
+ *   variable would silently point at someone else's server rather than being told.
+ * ⚠️ Read at CALL time, never at module scope — a value captured at import is pinned to
+ *   whatever the first isolate saw.
+ */
+export declare const apiBase: () => string;
+export declare class ForgejoError extends Error {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    constructor(status: number, method: string, path: string, detail: string);
+}
+/** One JSON call. Returns the parsed body, or `undefined` when the response is empty (DELETE). */
+export declare const forgejo: <T>(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, body?: Record<string, unknown>) => Effect.Effect<T, ForgejoError, HttpClient.HttpClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/forgejo/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/forgejo/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAC;AAK9D;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,QAAO,MAQ1B,CAAC;AAkBF,qBAAa,YAAa,SAAQ,KAAK;IAEnC,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM;IAHvB,YACW,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EAIf;CACF;AAQD,kGAAkG;AAClG,eAAO,MAAM,OAAO,GAAI,CAAC,UACf,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,QAC7C,MAAM,SACL,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,0DAwD5B,CAAC"}

package/dist/forgejo/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Forgejo providers for Alchemy.
+ *
+ * ⛔ THIS BARREL IS THE PUBLIC API, AND IT IS DELIBERATELY SMALLER THAN THE DIRECTORY.
+ *   These are the symbols a real stack consumes; the rest of the files are internals a
+ *   provider needs but a consumer should not depend on. An `export *` here would publish
+ *   every helper as API and make the next refactor a breaking change.
+ * ★ Anything unlisted is still reachable by path if you genuinely need it — that is a
+ *   deliberate, visible act rather than an accident of barrelling.
+ */
+export { ForgejoBranchProtectionProvider } from './branch-protection.ts';
+export { ForgejoOrgSecretProvider } from './org-actions-secrets.ts';
+export { ForgejoOrgLabel, ForgejoOrgLabelProvider, type OrgLabelProps } from './org-label.ts';
+export { ForgejoOrgTeamProvider } from './org-team.ts';
+export { ForgejoRepoWebhookProvider } from './repo-webhook.ts';
+export { ForgejoRepository, ForgejoRepositoryProvider } from './repository.ts';
+export { ForgejoTeamMember, ForgejoTeamMemberProvider } from './team-member.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/forgejo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/forgejo/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC9F,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/forgejo/index.js

@@ -0,0 +1,479 @@
+// src/forgejo/branch-protection.ts
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import * as Effect3 from "effect/Effect";
+
+// src/forgejo/branch-protection-form.ts
+var branchProtectionForm = (props) => ({
+  ...props.applyToAdmins === undefined ? {} : { apply_to_admins: props.applyToAdmins },
+  ...props.dismissStaleApprovals === undefined ? {} : { dismiss_stale_approvals: props.dismissStaleApprovals },
+  ...props.enablePush === undefined ? {} : { enable_push: props.enablePush },
+  ...props.enableStatusCheck === undefined ? {} : { enable_status_check: props.enableStatusCheck },
+  ...props.ignoreStaleApprovals === undefined ? {} : { ignore_stale_approvals: props.ignoreStaleApprovals },
+  ...props.requireSignedCommits === undefined ? {} : { require_signed_commits: props.requireSignedCommits },
+  ...props.requiredApprovals === undefined ? {} : { required_approvals: props.requiredApprovals },
+  ...props.statusCheckContexts === undefined ? {} : { status_check_contexts: props.statusCheckContexts },
+  rule_name: props.branchName
+});
+
+// src/forgejo/resource.ts
+import { isResolved } from "alchemy/Diff";
+import * as Effect2 from "effect/Effect";
+
+// src/forgejo/client.ts
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+var PATH_PREFIX = "/api/v1";
+var apiBase = () => {
+  const raw = process.env["FORGEJO_URL"];
+  if (raw === undefined || raw.trim() === "") {
+    throw new Error("FORGEJO_URL is not set. Point it at your Forgejo instance, e.g. https://git.example.com");
+  }
+  return raw.trim().replace(/\/$/, "");
+};
+var token = () => Effect.gen(function* () {
+  const raw = process.env["FORGEJO_TOKEN"];
+  if (raw === undefined || raw.trim() === "") {
+    return yield* Effect.fail(new ForgejoError(0, "GET", "", "FORGEJO_TOKEN is unset. Mint a scoped token and export it — never store it in Alchemy props."));
+  }
+  return raw.trim();
+});
+
+class ForgejoError extends Error {
+  status;
+  method;
+  path;
+  constructor(status, method, path, detail) {
+    super(`Forgejo ${method} ${path} -> ${String(status)}: ${detail}`);
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.name = "ForgejoError";
+  }
+}
+var authorization = (value) => ({ Authorization: `token ${value}` });
+var forgejo = (method, path, body) => Effect.gen(function* () {
+  const credential = yield* token();
+  const url = `${apiBase()}${PATH_PREFIX}/${path.replace(/^\//, "")}`;
+  const client = yield* HttpClient.HttpClient;
+  const request = HttpClientRequest.make(method)(url).pipe(HttpClientRequest.setHeaders({ ...authorization(credential), Accept: "application/json" }), body === undefined ? (self) => self : HttpClientRequest.bodyText(JSON.stringify(body), "application/json"));
+  const response = yield* client.execute(request).pipe(Effect.mapError((cause) => new ForgejoError(0, method, path, String(cause))));
+  if (response.status < 200 || response.status >= 300) {
+    const detail = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+    return yield* Effect.fail(new ForgejoError(response.status, method, path, detail.slice(0, 300)));
+  }
+  const text = yield* response.text.pipe(Effect.mapError((cause) => new ForgejoError(0, method, path, String(cause))));
+  return text === "" ? undefined : JSON.parse(text);
+});
+
+// src/forgejo/resource.ts
+var absentOn404 = (io) => io.pipe(Effect2.catchIf((cause) => cause instanceof ForgejoError && cause.status === 404, () => Effect2.succeed(undefined)));
+var forgejoOperations = (spec) => {
+  const fetchLive = (props) => absentOn404(spec.locate !== undefined ? spec.locate(props) : forgejo("GET", spec.path(props)));
+  const objectPath = (props, live) => spec.wirePath === undefined ? spec.path(props) : spec.wirePath(props, live);
+  const read = (props) => fetchLive(props).pipe(Effect2.map((data) => data === undefined ? undefined : spec.attributes(data, props)));
+  return {
+    read,
+    diff: (news, output) => Effect2.gen(function* () {
+      if (output === undefined || !isResolved(news))
+        return;
+      const live = yield* read(news);
+      if (live === undefined)
+        return { action: "update" };
+      if (spec.matches(live, news))
+        return { action: "noop" };
+      return spec.updateForm === undefined ? { action: "replace" } : { action: "update" };
+    }),
+    reconcile: (news) => Effect2.gen(function* () {
+      const before = yield* fetchLive(news);
+      if (spec.upsert !== undefined) {
+        yield* spec.upsert(news, before);
+      } else if (before === undefined) {
+        yield* forgejo("POST", spec.collection(news), spec.createForm(news));
+      } else if (spec.updateForm !== undefined) {
+        const mapped = spec.attributes(before, news);
+        if (mapped === undefined || spec.matches(mapped, news)) {} else {
+          const form = spec.updateForm(news);
+          if (Object.keys(form).length > 0) {
+            yield* forgejo("PATCH", objectPath(news, before), form);
+          }
+        }
+      }
+      const after = yield* read(news);
+      if (after === undefined) {
+        return yield* Effect2.die(new Error(`${spec.path(news)}: the write returned no error but the object is still absent. ` + "Gitea returns the object directly — read back rather than trusting the status code."));
+      }
+      return after;
+    }),
+    destroy: (olds) => Effect2.gen(function* () {
+      const live = yield* fetchLive(olds);
+      if (live === undefined)
+        return;
+      yield* forgejo("DELETE", objectPath(olds, live));
+    })
+  };
+};
+var forgejoHandlers = (spec) => {
+  const ops = forgejoOperations(spec);
+  return {
+    list: () => Effect2.succeed([]),
+    read: ({ olds }) => ops.read(olds),
+    diff: ({ news, output }) => ops.diff(news, output),
+    reconcile: ({ news }) => ops.reconcile(news),
+    delete: ({ olds }) => ops.destroy(olds)
+  };
+};
+
+// src/forgejo/values.ts
+var text = (value, fallback = "") => typeof value === "string" ? value : fallback;
+var color = (value) => text(value).replace(/^#/, "").toLowerCase();
+var bool = (value, fallback = false) => value === undefined || value === null ? fallback : value === true || value === 1 || value === "1";
+var int = (value, fallback = 0) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return Math.trunc(value);
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return fallback;
+};
+var stringArray = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string").toSorted() : [];
+var stringRecord = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string")
+      out[key] = entry;
+  }
+  return out;
+};
+var recordEqual = (left, right) => {
+  const leftKeys = Object.keys(left).toSorted();
+  const rightKeys = Object.keys(right).toSorted();
+  if (leftKeys.length !== rightKeys.length)
+    return false;
+  return leftKeys.every((key, index) => rightKeys[index] === key && left[key] === right[key]);
+};
+var hookConfigPublic = (value) => {
+  const config = stringRecord(value);
+  const { secret: _secret, ...rest } = config;
+  return rest;
+};
+var orgSecretEnvKey = (org, name) => `FORGEJO_ORG_SECRET_${org}_${name}`.replace(/[^A-Za-z0-9_]/g, "_").toUpperCase();
+var hookSecretEnvKey = (owner, repo, name) => `FORGEJO_HOOK_SECRET_${owner}_${repo}_${name}`.replace(/[^A-Za-z0-9_]/g, "_").toUpperCase();
+
+// src/forgejo/branch-protection.ts
+var ForgejoBranchProtection = Resource("Forgejo.BranchProtection", { defaultRemovalPolicy: "retain" });
+var handlers = forgejoHandlers({
+  attributes: (live, props) => {
+    const ruleName = text(live["rule_name"], text(live["branch_name"]));
+    if (ruleName === "")
+      return;
+    return {
+      applyToAdmins: bool(live["apply_to_admins"]),
+      branchName: props.branchName,
+      dismissStaleApprovals: bool(live["dismiss_stale_approvals"]),
+      enablePush: bool(live["enable_push"], true),
+      enableStatusCheck: bool(live["enable_status_check"]),
+      ignoreStaleApprovals: bool(live["ignore_stale_approvals"]),
+      owner: props.owner,
+      repo: props.repo,
+      requireSignedCommits: bool(live["require_signed_commits"]),
+      requiredApprovals: int(live["required_approvals"]),
+      statusCheckContexts: stringArray(live["status_check_contexts"])
+    };
+  },
+  collection: (props) => `repos/${props.owner}/${props.repo}/branch_protections`,
+  createForm: branchProtectionForm,
+  matches: (attributes, props) => attributes.requiredApprovals === (props.requiredApprovals ?? 0) && attributes.enablePush === (props.enablePush ?? true) && attributes.enableStatusCheck === (props.enableStatusCheck ?? false) && attributes.requireSignedCommits === (props.requireSignedCommits ?? false) && attributes.dismissStaleApprovals === (props.dismissStaleApprovals ?? false) && attributes.ignoreStaleApprovals === (props.ignoreStaleApprovals ?? false) && attributes.applyToAdmins === (props.applyToAdmins ?? false) && (props.statusCheckContexts === undefined || stringArray(props.statusCheckContexts).join("\x00") === attributes.statusCheckContexts.join("\x00")),
+  path: (props) => `repos/${props.owner}/${props.repo}/branch_protections/${props.branchName}`,
+  updateForm: branchProtectionForm
+});
+var ForgejoBranchProtectionProvider = () => Provider.effect(ForgejoBranchProtection, Effect3.succeed(ForgejoBranchProtection.Provider.of(handlers)));
+// src/forgejo/org-actions-secrets.ts
+import { Resource as Resource2 } from "alchemy";
+import * as Provider2 from "alchemy/Provider";
+import * as Effect4 from "effect/Effect";
+var ForgejoOrgSecret = Resource2("Forgejo.OrgSecret");
+var secretData = (org, name) => Effect4.gen(function* () {
+  const key = orgSecretEnvKey(org, name);
+  const raw = process.env[key];
+  if (raw === undefined || raw.trim() === "") {
+    return yield* Effect4.fail(new ForgejoError(0, "PUT", `orgs/${org}/actions/secrets/${name}`, `${key} is unset. Export the secret value there — never as an Alchemy prop.`));
+  }
+  return raw.trim();
+});
+var handlers2 = forgejoHandlers({
+  attributes: (live, props) => ({
+    createdAt: text(live["created_at"]),
+    name: props.name,
+    org: props.org
+  }),
+  collection: (props) => `orgs/${props.org}/actions/secrets/${props.name}`,
+  createForm: () => ({}),
+  locate: (props) => forgejo("GET", `orgs/${props.org}/actions/secrets?limit=200`).pipe(Effect4.map((rows) => Array.isArray(rows) ? rows.find((row) => row["name"] === props.name) : undefined)),
+  matches: () => true,
+  path: (props) => `orgs/${props.org}/actions/secrets/${props.name}`,
+  upsert: (props, before) => Effect4.gen(function* () {
+    if (before !== undefined)
+      return;
+    const data = yield* secretData(props.org, props.name);
+    yield* forgejo("PUT", `orgs/${props.org}/actions/secrets/${props.name}`, { data });
+  })
+});
+var ForgejoOrgSecretProvider = () => Provider2.effect(ForgejoOrgSecret, Effect4.succeed(ForgejoOrgSecret.Provider.of(handlers2)));
+// src/forgejo/org-label.ts
+import { Resource as Resource3 } from "alchemy";
+import * as Provider3 from "alchemy/Provider";
+import * as Effect5 from "effect/Effect";
+var ForgejoOrgLabel = Resource3("Forgejo.OrgLabel", {
+  defaultRemovalPolicy: "retain"
+});
+var handlers3 = forgejoHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    return {
+      color: color(live["color"]),
+      description: text(live["description"]),
+      exclusive: bool(live["exclusive"]),
+      labelId: id,
+      name: props.name,
+      org: props.org
+    };
+  },
+  collection: (props) => `orgs/${props.org}/labels`,
+  createForm: (props) => ({
+    color: color(props.color),
+    description: props.description ?? "",
+    exclusive: props.exclusive ?? false,
+    name: props.name
+  }),
+  locate: (props) => forgejo("GET", `orgs/${props.org}/labels?limit=200`).pipe(Effect5.map((rows) => Array.isArray(rows) ? rows.find((row) => row["name"] === props.name) : undefined)),
+  matches: (attributes, props) => attributes.color === color(props.color) && attributes.description === (props.description ?? "") && attributes.exclusive === (props.exclusive ?? false),
+  path: (props) => `orgs/${props.org}/labels/${props.name}`,
+  updateForm: (props) => ({
+    color: color(props.color),
+    description: props.description ?? "",
+    exclusive: props.exclusive ?? false
+  }),
+  wirePath: (props, live) => `orgs/${props.org}/labels/${String(live["id"])}`
+});
+var ForgejoOrgLabelProvider = () => Provider3.effect(ForgejoOrgLabel, Effect5.succeed(ForgejoOrgLabel.Provider.of(handlers3)));
+// src/forgejo/org-team.ts
+import { Resource as Resource4 } from "alchemy";
+import * as Provider4 from "alchemy/Provider";
+import * as Effect6 from "effect/Effect";
+var ForgejoOrgTeam = Resource4("Forgejo.OrgTeam");
+var teamForm = (props) => ({
+  can_create_org_repo: props.canCreateOrgRepo ?? false,
+  description: props.description ?? "",
+  includes_all_repositories: props.includesAllRepositories ?? false,
+  name: props.name,
+  ...props.permission === undefined ? {} : { permission: props.permission },
+  ...props.units === undefined ? {} : { units: props.units },
+  ...props.unitsMap === undefined ? {} : { units_map: props.unitsMap }
+});
+var handlers4 = forgejoHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    const permission = text(live["permission"], "read");
+    if (permission !== "read" && permission !== "write" && permission !== "admin")
+      return;
+    return {
+      canCreateOrgRepo: bool(live["can_create_org_repo"]),
+      description: text(live["description"]),
+      includesAllRepositories: bool(live["includes_all_repositories"]),
+      name: props.name,
+      org: props.org,
+      permission,
+      teamId: id,
+      units: stringArray(live["units"]),
+      unitsMap: stringRecord(live["units_map"])
+    };
+  },
+  collection: (props) => `orgs/${props.org}/teams`,
+  createForm: teamForm,
+  locate: (props) => forgejo("GET", `orgs/${props.org}/teams?limit=200`).pipe(Effect6.map((rows) => Array.isArray(rows) ? rows.find((row) => row["name"] === props.name) : undefined)),
+  matches: (attributes, props) => attributes.description === (props.description ?? "") && attributes.permission === (props.permission ?? "read") && attributes.includesAllRepositories === (props.includesAllRepositories ?? false) && attributes.canCreateOrgRepo === (props.canCreateOrgRepo ?? false) && (props.units === undefined || stringArray(props.units).join("\x00") === attributes.units.join("\x00")) && (props.unitsMap === undefined || recordEqual(attributes.unitsMap, props.unitsMap)),
+  path: (props) => `orgs/${props.org}/teams/${props.name}`,
+  updateForm: teamForm,
+  wirePath: (_props, live) => `teams/${String(live["id"])}`
+});
+var ForgejoOrgTeamProvider = () => Provider4.effect(ForgejoOrgTeam, Effect6.succeed(ForgejoOrgTeam.Provider.of(handlers4)));
+// src/forgejo/repo-webhook.ts
+import { Resource as Resource5 } from "alchemy";
+import * as Provider5 from "alchemy/Provider";
+import * as Effect7 from "effect/Effect";
+
+// src/forgejo/repo-webhook-form.ts
+var hookUrl = (live) => text(live["url"]) || text(stringRecord(live["config"])["url"]);
+var hookConfigForm = (props, includeSecret) => {
+  const config = {
+    content_type: props.contentType ?? "json",
+    url: props.url
+  };
+  if (includeSecret) {
+    const key = hookSecretEnvKey(props.owner, props.repo, props.name);
+    const secret = process.env[key]?.trim();
+    if (secret !== undefined && secret !== "")
+      config["secret"] = secret;
+  }
+  return config;
+};
+var createHookForm = (props) => ({
+  active: props.active ?? true,
+  ...props.authorizationHeader === undefined ? {} : { authorization_header: props.authorizationHeader },
+  ...props.branchFilter === undefined ? {} : { branch_filter: props.branchFilter },
+  config: hookConfigForm(props, true),
+  events: props.events,
+  name: props.name,
+  type: props.type
+});
+var updateHookForm = (props) => ({
+  active: props.active ?? true,
+  ...props.authorizationHeader === undefined ? {} : { authorization_header: props.authorizationHeader },
+  ...props.branchFilter === undefined ? {} : { branch_filter: props.branchFilter },
+  config: hookConfigForm(props, false),
+  events: props.events
+});
+
+// src/forgejo/repo-webhook.ts
+var ForgejoRepoWebhook = Resource5("Forgejo.RepoWebhook");
+var handlers5 = forgejoHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    const config = hookConfigPublic(live["config"]);
+    const type = text(live["type"]);
+    return {
+      active: bool(live["active"], true),
+      authorizationHeader: text(live["authorization_header"]),
+      branchFilter: text(live["branch_filter"]),
+      contentType: text(config["content_type"], text(live["content_type"], "json")),
+      events: stringArray(live["events"]),
+      hookId: id,
+      name: props.name,
+      owner: props.owner,
+      repo: props.repo,
+      type,
+      url: hookUrl(live)
+    };
+  },
+  collection: (props) => `repos/${props.owner}/${props.repo}/hooks`,
+  createForm: createHookForm,
+  locate: (props) => forgejo("GET", `repos/${props.owner}/${props.repo}/hooks?limit=200`).pipe(Effect7.map((rows) => Array.isArray(rows) ? rows.find((row) => text(row["name"]) === props.name || hookUrl(row) === props.url) : undefined)),
+  matches: (attributes, props) => attributes.type === props.type && attributes.url === props.url && attributes.active === (props.active ?? true) && attributes.contentType === (props.contentType ?? "json") && attributes.branchFilter === (props.branchFilter ?? "") && attributes.authorizationHeader === (props.authorizationHeader ?? "") && stringArray(props.events).join("\x00") === attributes.events.join("\x00"),
+  path: (props) => `repos/${props.owner}/${props.repo}/hooks/${props.name}`,
+  updateForm: updateHookForm,
+  wirePath: (props, live) => `repos/${props.owner}/${props.repo}/hooks/${String(live["id"])}`
+});
+var ForgejoRepoWebhookProvider = () => Provider5.effect(ForgejoRepoWebhook, Effect7.succeed(ForgejoRepoWebhook.Provider.of(handlers5)));
+// src/forgejo/repository.ts
+import { Resource as Resource6 } from "alchemy";
+import * as Provider6 from "alchemy/Provider";
+import * as Effect8 from "effect/Effect";
+var ForgejoRepository = Resource6("Forgejo.Repository", {
+  defaultRemovalPolicy: "retain"
+});
+var handlers6 = forgejoHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    return {
+      defaultBranch: text(live["default_branch"], "main"),
+      description: text(live["description"]),
+      empty: bool(live["empty"]),
+      hasIssues: bool(live["has_issues"], true),
+      hasProjects: bool(live["has_projects"], true),
+      hasWiki: bool(live["has_wiki"], true),
+      name: props.name,
+      org: props.org,
+      private: bool(live["private"], true),
+      repoId: id
+    };
+  },
+  collection: (props) => `orgs/${props.org}/repos`,
+  createForm: (props) => ({
+    auto_init: props.autoInit ?? false,
+    description: props.description ?? "",
+    has_issues: props.hasIssues ?? true,
+    has_projects: props.hasProjects ?? true,
+    has_wiki: props.hasWiki ?? true,
+    name: props.name,
+    private: props.private ?? true
+  }),
+  matches: (attributes, props) => (props.description === undefined || attributes.description === props.description) && (props.private === undefined || attributes.private === props.private) && (props.hasIssues === undefined || attributes.hasIssues === props.hasIssues) && (props.hasWiki === undefined || attributes.hasWiki === props.hasWiki) && (props.hasProjects === undefined || attributes.hasProjects === props.hasProjects) && (props.defaultBranch === undefined || attributes.defaultBranch === props.defaultBranch),
+  path: (props) => `repos/${props.org}/${props.name}`,
+  updateForm: (props) => ({
+    ...props.defaultBranch === undefined ? {} : { default_branch: props.defaultBranch },
+    ...props.description === undefined ? {} : { description: props.description },
+    ...props.hasIssues === undefined ? {} : { has_issues: props.hasIssues },
+    ...props.hasProjects === undefined ? {} : { has_projects: props.hasProjects },
+    ...props.hasWiki === undefined ? {} : { has_wiki: props.hasWiki },
+    ...props.private === undefined ? {} : { private: props.private }
+  })
+});
+var ForgejoRepositoryProvider = () => Provider6.effect(ForgejoRepository, Effect8.succeed(ForgejoRepository.Provider.of(handlers6)));
+// src/forgejo/team-member.ts
+import { Resource as Resource7 } from "alchemy";
+import * as Provider7 from "alchemy/Provider";
+import * as Effect9 from "effect/Effect";
+var ForgejoTeamMember = Resource7("Forgejo.TeamMember");
+var TEAM_ID = "__team_id";
+var teamIdOf = (props) => Effect9.gen(function* () {
+  const path = `orgs/${props.org}/teams?limit=200`;
+  const rows = yield* forgejo("GET", path);
+  const id = (Array.isArray(rows) ? rows : []).find((row) => row["name"] === props.team)?.["id"];
+  if (typeof id !== "number") {
+    return yield* Effect9.fail(new ForgejoError(0, "GET", path, `no team named ${props.team} in org ${props.org}`));
+  }
+  return id;
+});
+var memberPath = (id, props) => `teams/${String(id)}/members/${props.username}`;
+var handlers7 = forgejoHandlers({
+  attributes: (live, props) => {
+    const id = live[TEAM_ID];
+    const login = live["login"];
+    if (typeof id !== "number" || typeof login !== "string")
+      return;
+    if (login.toLowerCase() !== props.username.toLowerCase())
+      return;
+    return { org: props.org, team: props.team, teamId: id, username: props.username };
+  },
+  collection: (props) => `orgs/${props.org}/teams`,
+  createForm: () => ({}),
+  locate: (props) => Effect9.gen(function* () {
+    const id = yield* teamIdOf(props);
+    const user = yield* forgejo("GET", memberPath(id, props));
+    return user === undefined ? undefined : { ...user, [TEAM_ID]: id };
+  }),
+  matches: () => true,
+  path: (props) => `orgs/${props.org}/teams/${props.team}/members/${props.username}`,
+  upsert: (props, before) => before !== undefined ? Effect9.void : Effect9.flatMap(teamIdOf(props), (id) => Effect9.asVoid(forgejo("PUT", memberPath(id, props)))),
+  wirePath: (props, live) => memberPath(Number(live[TEAM_ID]), props)
+});
+var ForgejoTeamMemberProvider = () => Provider7.effect(ForgejoTeamMember, Effect9.succeed(ForgejoTeamMember.Provider.of(handlers7)));
+export {
+  ForgejoBranchProtectionProvider,
+  ForgejoOrgLabel,
+  ForgejoOrgLabelProvider,
+  ForgejoOrgSecretProvider,
+  ForgejoOrgTeamProvider,
+  ForgejoRepoWebhookProvider,
+  ForgejoRepository,
+  ForgejoRepositoryProvider,
+  ForgejoTeamMember,
+  ForgejoTeamMemberProvider
+};
+
+//# debugId=09F62B41760BE1CD64756E2164756E21
+//# sourceMappingURL=index.js.map