@pipefy/pipefy-process-coder 0.1.0 → 0.1.2

package/src/pipefy/client.ts

@@ -1,267 +0,0 @@
-import { ENDPOINTS, type TokenProvider } from '../config.ts';
-import { debug } from '../util/log.ts';
-import { retry } from '../util/pool.ts';
-
-export type GqlError = { message: string; path?: unknown[]; extensions?: Record<string, unknown> };
-
-export class GraphQLRequestError extends Error {
-  errors: GqlError[];
-  retryable: boolean;
-  status: number;
-  constructor(message: string, errors: GqlError[], status: number, retryable: boolean) {
-    super(message);
-    this.name = 'GraphQLRequestError';
-    this.errors = errors;
-    this.status = status;
-    this.retryable = retryable;
-  }
-}
-
-const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
-
-/** Rate limiting and transient upstream faults are retryable; a bad query is not. */
-const isRetryableMessage = (m: string) =>
-  /rate limit|too many requests|timeout|timed out|temporarily|try again|internal server error/i.test(m);
-
-export type ClientOpts = {
-  /**
-   * A literal token, or a provider. The toolkit hands out short-lived OAuth
-   * access tokens, so a long apply needs to be able to ask for a fresh one —
-   * see src/config.ts.
-   */
-  token: string | TokenProvider;
-  endpoint?: string;
-  label?: string;
-};
-
-export class PipefyClient {
-  private readonly tokenProvider: TokenProvider;
-  readonly endpoint: string;
-  /** Every request, for `--stats` and for measuring the rate-limit ceiling. */
-  requestCount = 0;
-  retryCount = 0;
-  /** Times a 401 forced a credential refresh. Surfaced by `pipe doctor`. */
-  reauthCount = 0;
-
-  private typeFieldCache = new Map<string, Set<string> | null>();
-  private inputFieldCache = new Map<string, Set<string> | null>();
-  private requiredInputCache = new Map<string, Set<string>>();
-  private mutationInputTypeCache = new Map<string, string | null>();
-
-  constructor(opts: ClientOpts) {
-    this.tokenProvider = typeof opts.token === 'string' ? async () => opts.token as string : opts.token;
-    this.endpoint = opts.endpoint ?? ENDPOINTS.graphql;
-  }
-
-  /** The current bearer, refreshed only when something rejected the last one. */
-  async token(forceRefresh = false): Promise<string> {
-    if (forceRefresh) this.reauthCount++;
-    return this.tokenProvider({ forceRefresh });
-  }
-
-  async raw<T>(query: string, variables?: Record<string, unknown>, label?: string): Promise<T> {
-    let refreshed = false;
-    return retry(
-      async () => {
-        this.requestCount++;
-        const res = await fetch(this.endpoint, {
-          method: 'POST',
-          headers: {
-            authorization: `Bearer ${await this.token()}`,
-            'content-type': 'application/json',
-            accept: 'application/json',
-          },
-          body: JSON.stringify({ query, variables: variables ?? {} }),
-        });
-
-        /**
-         * An expired OAuth access token looks like a 401. Refresh once and let
-         * the retry loop send it again; a second 401 is a real permission
-         * problem and must not spin.
-         */
-        if ((res.status === 401 || res.status === 403) && !refreshed) {
-          refreshed = true;
-          await this.token(true);
-          const err = new Error(`HTTP ${res.status} — credential refreshed, retrying`);
-          (err as { retryable?: boolean }).retryable = true;
-          throw err;
-        }
-
-        const text = await res.text();
-        let body: { data?: T; errors?: GqlError[] } = {};
-        try {
-          body = text ? (JSON.parse(text) as typeof body) : {};
-        } catch {
-          const retryable = RETRYABLE_STATUS.has(res.status);
-          throw new GraphQLRequestError(
-            `HTTP ${res.status} from ${this.endpoint}: ${text.slice(0, 200)}`,
-            [],
-            res.status,
-            retryable,
-          );
-        }
-
-        if (body.errors?.length) {
-          const msg = body.errors.map((e) => e.message).join('; ');
-          const retryable = RETRYABLE_STATUS.has(res.status) || isRetryableMessage(msg);
-          throw new GraphQLRequestError(msg, body.errors, res.status, retryable);
-        }
-        if (!res.ok) {
-          throw new GraphQLRequestError(
-            `HTTP ${res.status} from ${this.endpoint}`,
-            [],
-            res.status,
-            RETRYABLE_STATUS.has(res.status),
-          );
-        }
-        if (body.data === undefined || body.data === null) {
-          throw new GraphQLRequestError('GraphQL response had no data', [], res.status, false);
-        }
-        return body.data;
-      },
-      { label: label ?? 'graphql' },
-    );
-  }
-
-  /** A query whose failure is a fact about the endpoint, not an error. */
-  async tryRaw<T>(query: string, variables?: Record<string, unknown>, label?: string): Promise<T | null> {
-    try {
-      return await this.raw<T>(query, variables, label);
-    } catch (e) {
-      debug(`probe failed (${label ?? 'unnamed'}): ${(e as Error).message}`);
-      return null;
-    }
-  }
-
-  /**
-   * Which fields a type actually has.
-   *
-   * The reconstruction path (reconstruct.ts) asks for columns that PLAN.md marks
-   * unverified. Rather than sending a query that fails wholesale on one unknown
-   * field, we introspect once and ask only for what exists. One cheap query
-   * buys a read path that degrades field-by-field instead of all-or-nothing.
-   */
-  async typeFields(typeName: string): Promise<Set<string> | null> {
-    if (this.typeFieldCache.has(typeName)) return this.typeFieldCache.get(typeName) ?? null;
-    const data = await this.tryRaw<{ __type: { fields: Array<{ name: string }> | null } | null }>(
-      'query($n:String!){ __type(name:$n){ fields{ name } } }',
-      { n: typeName },
-      `introspect ${typeName}`,
-    );
-    const fields = data?.__type?.fields;
-    const set = fields ? new Set(fields.map((f) => f.name)) : null;
-    this.typeFieldCache.set(typeName, set);
-    return set;
-  }
-
-  /** Whether a mutation exists — the basis of capability detection (PLAN.md §1.2). */
-  async hasMutation(name: string): Promise<boolean> {
-    const fields = await this.typeFields('Mutation');
-    if (!fields) return false;
-    return fields.has(name);
-  }
-
-  /**
-   * The named type of a mutation's `input` argument.
-   *
-   * Never guessed. The registry documents traps like `createFieldConditionInput`
-   * being lowercase-c while `UpdateFieldConditionInput` is not; asking the schema
-   * removes a whole class of "mutation exists, input type name wrong" failures.
-   */
-  async mutationInputType(mutation: string): Promise<string | null> {
-    if (this.mutationInputTypeCache.has(mutation)) return this.mutationInputTypeCache.get(mutation) ?? null;
-    const data = await this.tryRaw<{
-      __type: {
-        fields: Array<{
-          name: string;
-          args: Array<{ name: string; type: TypeRef }>;
-        }> | null;
-      } | null;
-    }>(
-      `query {
-        __type(name: "Mutation") {
-          fields {
-            name
-            args { name type { kind name ofType { kind name ofType { kind name } } } }
-          }
-        }
-      }`,
-      undefined,
-      'introspect Mutation args',
-    );
-    const field = data?.__type?.fields?.find((f) => f.name === mutation);
-    const arg = field?.args.find((a) => a.name === 'input') ?? field?.args[0];
-    const named = arg ? unwrapTypeName(arg.type) : null;
-    this.mutationInputTypeCache.set(mutation, named);
-    return named;
-  }
-
-  /**
-   * Input fields that are NON_NULL with no default — the ones a request must
-   * carry a value for.
-   *
-   * CreatePipeRelationInput makes every boolean required, including
-   * autoFillFieldEnabled, which the snapshot payload has no column for at all.
-   * Sent without it the mutation is rejected mid-apply; knowing up front turns
-   * that into something `pipe plan` can say before anything is written.
-   */
-  async requiredInputFields(typeName: string): Promise<Set<string>> {
-    const cached = this.requiredInputCache.get(typeName);
-    if (cached) return cached;
-    const data = await this.tryRaw<{
-      __type: { inputFields: Array<{ name: string; defaultValue: string | null; type: { kind: string } }> | null } | null;
-    }>(
-      'query($n:String!){ __type(name:$n){ inputFields { name defaultValue type { kind } } } }',
-      { n: typeName },
-      `introspect required ${typeName}`,
-    );
-    const req = new Set<string>();
-    for (const fld of data?.__type?.inputFields ?? []) {
-      if (fld.type.kind === 'NON_NULL' && fld.defaultValue === null) req.add(fld.name);
-    }
-    this.requiredInputCache.set(typeName, req);
-    return req;
-  }
-
-  /** The fields an input object type accepts. */
-  async inputFields(typeName: string): Promise<Set<string> | null> {
-    if (this.inputFieldCache.has(typeName)) return this.inputFieldCache.get(typeName) ?? null;
-    const data = await this.tryRaw<{ __type: { inputFields: Array<{ name: string }> | null } | null }>(
-      'query($n:String!){ __type(name:$n){ inputFields{ name } } }',
-      { n: typeName },
-      `introspect input ${typeName}`,
-    );
-    const fields = data?.__type?.inputFields;
-    const set = fields ? new Set(fields.map((f) => f.name)) : null;
-    this.inputFieldCache.set(typeName, set);
-    return set;
-  }
-
-  /**
-   * Filter a wanted selection down to what the type has. `selection` entries may
-   * be a bare field (`"label"`) or a field with a sub-selection
-   * (`["connectedRepo", "{ id name }"]`).
-   */
-  async prune(typeName: string, selection: Array<string | [string, string]>): Promise<string> {
-    const have = await this.typeFields(typeName);
-    const keep: string[] = [];
-    for (const s of selection) {
-      const [name, sub] = Array.isArray(s) ? s : [s, ''];
-      if (have && !have.has(name)) {
-        debug(`skipping ${typeName}.${name} — not in schema`);
-        continue;
-      }
-      keep.push(sub ? `${name} ${sub}` : name);
-    }
-    return keep.join('\n      ');
-  }
-}
-
-type TypeRef = { kind: string; name: string | null; ofType?: TypeRef | null };
-
-/** Unwrap NON_NULL / LIST wrappers down to the named type. */
-const unwrapTypeName = (t: TypeRef | null | undefined): string | null => {
-  let cur: TypeRef | null | undefined = t;
-  while (cur && !cur.name) cur = cur.ofType ?? null;
-  return cur?.name ?? null;
-};

package/src/pipefy/discovery.ts

@@ -1,209 +0,0 @@
-import { debug, step, warn } from '../util/log.ts';
-import { rel, type RepoPayload, type Row } from '../model/payload.ts';
-import type { PipefyClient } from './client.ts';
-
-/**
- * Connection discovery. PLAN.md §2.2 — the finding that would have silently
- * broken the core requirement:
- *
- *   - `relations.pipe_relations` is [] even for a pipe with two live connections
- *   - `pipeMapGraph(depth: 3)` returns one node and zero edges for that pipe
- *
- * So neither is the source of truth. Discovery is the union of three sources,
- * walked transitively and deduplicated by repo identity.
- */
-
-export type RepoKind = 'pipe' | 'table';
-
-export type RepoRef = {
-  kind: RepoKind;
-  /** Numeric id, which both the pipe and table APIs accept. */
-  id: number;
-  /** Table API ids round-trip as a slug (`dzmxcuxz`); pipes return numbers. */
-  apiId: string;
-  name?: string | null;
-  uuid?: string | null;
-  /** How this repo was found, for the manifest and the UI. */
-  via: string[];
-  depth: number;
-};
-
-export type DiscoveryResult = {
-  /** Every repo to pull, root first. */
-  repos: RepoRef[];
-  /** Edges, for the graph view and for MAPPING.md. */
-  edges: Array<{ from: number; to: number; kind: string; label?: string }>;
-  warnings: string[];
-};
-
-const asNum = (v: unknown): number | null => {
-  if (v === null || v === undefined || v === '') return null;
-  const n = Number(v);
-  return Number.isFinite(n) ? n : null;
-};
-
-/** The three sources, applied to one already-read payload. */
-export const edgesFromPayload = (p: RepoPayload): Array<{ to: number; kind: string; label?: string }> => {
-  const self = Number(p.id);
-  const out: Array<{ to: number; kind: string; label?: string }> = [];
-
-  // 1. pipe_relations
-  for (const r of rel(p, 'pipe_relations')) {
-    for (const key of ['parent_id', 'child_id']) {
-      const id = asNum(r[key]);
-      if (id !== null && id !== self) out.push({ to: id, kind: 'pipe_relation', label: String(r['name'] ?? '') });
-    }
-  }
-
-  // 2. connector fields — the only source that finds the test pipe's two
-  //    connections, and the reason this function exists.
-  for (const f of rel(p, 'fields')) {
-    if (f['type_id'] !== 'connector') continue;
-    const id = asNum(f['connected_pipe_id']);
-    if (id !== null && id !== self) out.push({ to: id, kind: 'connector_field', label: String(f['label'] ?? '') });
-  }
-
-  // 3. cross-repo automations
-  for (const a of rel(p, 'automations')) {
-    for (const key of ['event_repo_id', 'action_repo_id']) {
-      const id = asNum(a[key]);
-      if (id !== null && id !== self) out.push({ to: id, kind: 'automation', label: String(a['name'] ?? '') });
-    }
-  }
-
-  return out;
-};
-
-/**
- * Resolve a numeric repo id to what it actually is.
- *
- * **Neither root field discriminates.** Verified live: `pipe(id:)` and
- * `table(id:)` both answer for *every* repo id, and both return plausible data —
- * `pipe.phases` on a database returns its status phases, and `table.table_fields`
- * on a pipe returns its start-form fields. A repo is one object viewed two ways.
- * Trying `pipe` first and taking the win, as an earlier version did, classified
- * every database as a pipe.
- *
- * `Table.url` is the real discriminator: a pipe lives at `/pipes/<id>` and a
- * database at `/apollo_databases/<id>`. One query settles both the kind and
- * PLAN.md §2.2's id duality, since `Table` carries the slug as `id` and the
- * numeric form as `internal_id`.
- */
-/**
- * Resolve one repo id, in **either** spelling.
- *
- * `table(id:)` accepts a database's numeric internal id and its api id (a slug
- * like `dzmxcuxz`) and always answers with the slug — measured both ways. So
- * `pipe pull 302908356` and `pipe pull 3LhkZu_h` must reach the same database,
- * and the `RepoRef` this returns normalises to the numeric id either way, which
- * is what keeps one database from being pulled twice under two identities.
- */
-export const resolveRepo = async (client: PipefyClient, id: number | string): Promise<RepoRef | null> => {
-  const res = await client.tryRaw<{
-    table: { id: string; internal_id?: string | null; name: string; uuid?: string | null; url?: string | null } | null;
-  }>(
-    `query($id: ID!) { table(id: $id) { id internal_id name uuid url } }`,
-    { id: String(id) },
-    `resolve repo ${id}`,
-  );
-  const repo = res?.table;
-  if (!repo) return null;
-
-  const url = String(repo.url ?? '');
-  const kind: RepoKind = /apollo_databases/.test(url) ? 'table' : 'pipe';
-  debug(`repo ${id} is a ${kind} (${url || 'no url'})`);
-
-  return {
-    kind,
-    id: Number(repo.internal_id ?? id),
-    /** The slug for a database, the numeric string for a pipe. */
-    apiId: kind === 'table' ? String(repo.id) : String(repo.internal_id ?? id),
-    name: repo.name,
-    uuid: repo.uuid ?? null,
-    via: [],
-    depth: 0,
-  };
-};
-
-export type DiscoverOpts = {
-  depth: number;
-  /** Read a repo's payload; supplied by the pull command so both read paths work. */
-  read: (ref: RepoRef) => Promise<RepoPayload | null>;
-};
-
-/**
- * Walk outward from a root repo. `read` is injected so discovery works
- * identically whether payloads come from snapshots or from reconstruction.
- */
-export const discover = async (
-  client: PipefyClient,
-  rootId: number,
-  opts: DiscoverOpts,
-): Promise<DiscoveryResult> => {
-  const found = new Map<number, RepoRef>();
-  const edges: DiscoveryResult['edges'] = [];
-  const warnings: string[] = [];
-
-  const root = await resolveRepo(client, rootId);
-  if (!root) throw new Error(`repo ${rootId} is neither a readable pipe nor a readable table`);
-  root.via = ['root'];
-  found.set(rootId, root);
-
-  let frontier: RepoRef[] = [root];
-  for (let depth = 0; depth <= opts.depth && frontier.length; depth++) {
-    const next: RepoRef[] = [];
-    for (const ref of frontier) {
-      if (depth === opts.depth) break;
-      const payload = await opts.read(ref);
-      if (!payload) {
-        warnings.push(`${ref.kind} ${ref.id} (${ref.name ?? '?'}) could not be read — its connections are unexplored`);
-        continue;
-      }
-      for (const e of edgesFromPayload(payload)) {
-        edges.push({ from: ref.id, to: e.to, kind: e.kind, label: e.label });
-        const seen = found.get(e.to);
-        if (seen) {
-          if (!seen.via.includes(e.kind)) seen.via.push(e.kind);
-          continue;
-        }
-        const resolved = await resolveRepo(client, e.to);
-        if (!resolved) {
-          warnings.push(
-            `${ref.kind} ${ref.id} references repo ${e.to} via ${e.kind}, but the token cannot read it — ` +
-              `the pull is partial (PLAN.md §9, cross-repo permission)`,
-          );
-          continue;
-        }
-        resolved.via = [e.kind];
-        resolved.depth = depth + 1;
-        found.set(e.to, resolved);
-        next.push(resolved);
-        debug(`discovered ${resolved.kind} ${resolved.id} "${resolved.name}" via ${e.kind}`);
-      }
-    }
-    frontier = next;
-  }
-
-  const repos = [...found.values()].sort((a, b) => a.depth - b.depth || a.id - b.id);
-  step(`discovered ${repos.length} repo${repos.length === 1 ? '' : 's'} within depth ${opts.depth}`);
-  for (const w of warnings) warn(w);
-  return { repos, edges, warnings };
-};
-
-/**
- * `pipeMapGraph` is kept for the graph view and for `hasHiddenAutomations` —
- * never as the discovery mechanism. PLAN.md §2.2 and ask 7.
- */
-export const mapGraph = async (client: PipefyClient, repoId: number, depth = 2) => {
-  const data = await client.tryRaw<{ pipeMapGraph: unknown }>(
-    `query($id: ID!, $depth: Int) {
-      pipeMapGraph(pipeId: $id, depth: $depth) {
-        nodes { id name __typename hasHiddenAutomations hasHiddenIntegrations }
-        edges { from to }
-      }
-    }`,
-    { id: String(repoId), depth },
-    'pipeMapGraph',
-  );
-  return data?.pipeMapGraph ?? null;
-};