@percher/core 0.4.0 → 0.4.1

package/dist/commands/migrate-supabase-sdk.d.ts

@@ -0,0 +1,133 @@
+import { type API, type FileInfo, type Options } from "jscodeshift";
+/**
+ * FUTURE9 Phase D chunk 1 — Supabase JS SDK → PocketBase JS SDK
+ * source rewriter (single-file, pure).
+ *
+ * Pure function: takes a source-string + file-path hint, returns
+ * the rewritten source + a structured `flags[]` array describing
+ * every transformation (or refusal to transform). No I/O.
+ *
+ * Why pure: the file walker (chunk 3) drives this against every
+ * `.ts`/`.tsx`/`.js`/`.jsx` file in the project. Keeping the
+ * rewriter I/O-free means tests pin exact before/after pairs
+ * without disk, AND the walker can `--dry-run` the whole project
+ * by collecting flag totals without writing anything.
+ *
+ * AST library choice: jscodeshift. Matches the plan in
+ * docs/plans/FUTURE9_fas-8-lovable-migration-plan.md (Decision 4)
+ * and has the test-harness story we want. ts-morph would be the
+ * alternative if/when we hit TS-specific shape problems.
+ *
+ * Scope of THIS chunk (chunk 1): high-confidence rewrites only.
+ *   - supabase.auth.signInWithPassword({email, password})
+ *   - supabase.auth.signUp({email, password})
+ *   - supabase.auth.signOut()
+ *   - supabase.auth.getUser()
+ *   - supabase.from("t").select("*" | "a,b")     → getFullList
+ *   - supabase.from("t").insert({...})           → create
+ *   - supabase.from("t").update({...}).eq("id", v) → update(v, {...})
+ *   - supabase.from("t").delete().eq("id", v)    → delete(v)
+ *
+ * Chunk 2 will add medium-confidence (.eq() filters, .order,
+ * .range, .onAuthStateChange). Chunk 3 will add flag-only handling
+ * for low-confidence patterns (storage, channel/subscribe, rpc,
+ * functions) and the file walker that drives this against a project.
+ *
+ * Safety invariants pinned by tests:
+ *   - Files that don't import @supabase/supabase-js are returned
+ *     unchanged with zero flags.
+ *   - Every transformation produces a corresponding `flags[]` entry
+ *     with before/after text and line/column. The caller can render
+ *     a diff log without re-parsing.
+ *   - The PB client identifier (default `pb`) is configurable so
+ *     a project that uses a different name doesn't get
+ *     double-imports.
+ *   - Surrounding code shape is preserved (no formatting drift) —
+ *     jscodeshift's recast-based printer round-trips untouched code.
+ */
+export type RewriteFlagKind = 
+/** Mapped 1:1 with no caveats — safe to use as-is. */
+"rewritten"
+/** Mapped but the semantics differ in ways the user should review. */
+ | "manual_review"
+/** Source has a pattern we won't auto-translate (subscribe, rpc, storage etc.). Inserted as-is with a TODO comment. */
+ | "unsupported";
+export interface RewriteFlag {
+    kind: RewriteFlagKind;
+    /** Stable short id for the pattern matched. Tests/reports key on this. */
+    pattern: string;
+    /** Source line (1-based) of the original call. Undefined if jscodeshift can't recover. */
+    line?: number;
+    /** Source column (0-based). Undefined if jscodeshift can't recover. */
+    column?: number;
+    /** Short human-readable summary the file walker can roll up. */
+    note: string;
+}
+export interface RewriteSupabaseSdkInput {
+    /** File source string. */
+    source: string;
+    /** Path the source came from (used in flag.note for context, not for I/O). */
+    filePath?: string;
+    /**
+     * Identifier name PocketBase will live under in the rewritten
+     * source. Defaults to `pb` — matches PocketBase's docs convention.
+     * Override when the project already has a `pb` binding for
+     * something else.
+     */
+    pbIdentifier?: string;
+    /**
+     * Identifier name(s) the Supabase client lives under in the source.
+     * Default: ["supabase"]. The rewriter walks the AST looking for
+     * member access on these names. Pass extra names when a project
+     * uses `const sb = createClient(...)` or `const client = ...`.
+     */
+    supabaseIdentifiers?: string[];
+}
+export interface RewriteSupabaseSdkResult {
+    /** The new source. Equals input.source byte-for-byte when no AST mutation happened. */
+    rewritten: string;
+    /** Flags for every transformation OR flagged-untransformed call. Empty array means nothing matched. */
+    flags: RewriteFlag[];
+    /**
+     * True when the AST was mutated and `rewritten` differs from
+     * `source` — the file walker keys writes on this.
+     *
+     * NOT the same as `flags.length > 0`: `manual_review` flags may
+     * land WITHOUT a mutation (e.g. `consumesDataErrorEnvelope`
+     * downgrades the rewrite without touching the AST so the file
+     * stays byte-identical, but a flag still records the call site
+     * for the human review report). If you want "did anything
+     * match", check `flags.length > 0` directly. Codex P2 round 6
+     * (2026-05-17) — earlier doc said `flags.length > 0` and the
+     * implementation drifted.
+     */
+    changed: boolean;
+    /**
+     * Set when the source failed to parse — the file is returned
+     * unchanged and no rewrite was attempted. Distinct from "no
+     * Supabase calls found" which leaves this undefined. Callers
+     * (the project walker) use this to classify the file as
+     * `skipped[reason="parse_error"]` instead of folding it into
+     * the clean-files report, which would silently hide files the
+     * migration couldn't analyse. Codex P2 round 10 (2026-05-17).
+     */
+    parseError?: string;
+}
+/**
+ * Rewrite Supabase JS SDK calls into PocketBase JS SDK calls.
+ *
+ * Pure (no I/O). Idempotent — feeding the output back in produces
+ * the same output with an empty flags array (already-rewritten
+ * code has no Supabase calls left to match).
+ */
+export declare function rewriteSupabaseSdk(input: RewriteSupabaseSdkInput): RewriteSupabaseSdkResult;
+/**
+ * Entry point matching jscodeshift's `transform` signature, in case
+ * a caller wants to run this as a standalone codemod via the
+ * jscodeshift CLI (`jscodeshift -t this-file.js src/`). Not used by
+ * Percher's own file walker — that calls `rewriteSupabaseSdk`
+ * directly for control over the flag-stream — but exposing it keeps
+ * the door open for ad-hoc usage.
+ */
+export default function transform(file: FileInfo, _api: API, options?: Options): string | null;
+//# sourceMappingURL=migrate-supabase-sdk.d.ts.map

package/dist/commands/migrate-supabase-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-supabase-sdk.d.ts","sourceRoot":"","sources":["../../src/commands/migrate-supabase-sdk.ts"],"names":[],"mappings":"AAAA,OAAoB,EAClB,KAAK,GAAG,EAGR,KAAK,QAAQ,EACb,KAAK,OAAO,EACb,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,MAAM,MAAM,eAAe;AACzB,sDAAsD;AACpD,WAAW;AACb,sEAAsE;GACpE,eAAe;AACjB,uHAAuH;GACrH,aAAa,CAAC;AAElB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,0FAA0F;IAC1F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,wBAAwB;IACvC,uFAAuF;IACvF,SAAS,EAAE,MAAM,CAAC;IAClB,uGAAuG;IACvG,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAKD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,wBAAwB,CAsD3F;AAgmDD;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,GAAE,OAAY,GAAG,MAAM,GAAG,IAAI,CAOjG"}