@mondaydotcomorg/z2h-cli 0.29.5 → 0.31.0

package/dist/esm/backend/ast.mjs

@@ -1,144 +0,0 @@
-import { full, simple } from 'acorn-walk';
-
-/**
- * Every identifier a binding pattern introduces, with its property path from the
- * pattern's value. `path` is deliberately not defaulted: callers pass `[]` for
- * the root and `undefined` once the pattern stops being a plain property read.
- */
-function patternBindings(pattern, path) {
-    switch (pattern.type) {
-        case 'Identifier':
-            return [{ name: pattern.name, path }];
-        case 'ObjectPattern':
-            return pattern.properties.flatMap(p => {
-                if (p.type === 'RestElement') {
-                    return patternBindings(p.argument, undefined);
-                }
-                const key = propertyKey(p.key, p.computed);
-                return patternBindings(p.value, path && key !== undefined ? [...path, key] : undefined);
-            });
-        case 'ArrayPattern':
-            return pattern.elements.flatMap(e => (e ? patternBindings(e, undefined) : []));
-        case 'AssignmentPattern':
-            return patternBindings(pattern.left, undefined);
-        case 'RestElement':
-            return patternBindings(pattern.argument, undefined);
-        default:
-            // MemberExpression targets (`obj.x = …`) bind no names.
-            return [];
-    }
-}
-function propertyKey(key, computed) {
-    if (key.type === 'Literal' && typeof key.value === 'string') {
-        return key.value;
-    }
-    if (!computed && key.type === 'Identifier') {
-        return key.name;
-    }
-    return undefined;
-}
-/** Every identifier a binding pattern introduces (`{ a, b: [c] } = …` → a, c). */
-const patternNames = (pattern) => patternBindings(pattern, []).map(b => b.name);
-function collectBindings(program) {
-    const declarations = new Map();
-    const unpinnable = new Set();
-    const markUnpinnable = (pattern) => patternNames(pattern).forEach(n => unpinnable.add(n));
-    full(program, node => {
-        switch (node.type) {
-            case 'VariableDeclaration':
-                for (const declarator of node.declarations) {
-                    for (const { name, path } of patternBindings(declarator.id, [])) {
-                        const list = declarations.get(name) ?? [];
-                        list.push({ kind: node.kind, init: declarator.init, path });
-                        declarations.set(name, list);
-                    }
-                }
-                break;
-            case 'AssignmentExpression':
-                markUnpinnable(node.left);
-                break;
-            case 'UpdateExpression':
-                if (node.argument.type === 'Identifier') {
-                    unpinnable.add(node.argument.name);
-                }
-                break;
-            case 'ForInStatement':
-            case 'ForOfStatement':
-                if (node.left.type !== 'VariableDeclaration') {
-                    markUnpinnable(node.left);
-                }
-                break;
-            case 'FunctionDeclaration':
-            case 'FunctionExpression':
-            case 'ArrowFunctionExpression':
-                node.params.forEach(markUnpinnable);
-                break;
-            case 'CatchClause':
-                if (node.param) {
-                    markUnpinnable(node.param);
-                }
-                break;
-        }
-    });
-    return { declarations, unpinnable };
-}
-/** `a.b.c` / `a['b'].c` → root `a`, parts `[b, c]`; `undefined` if any link is dynamic or the root is not an identifier. */
-function memberChain(node) {
-    if (node.type === 'ChainExpression') {
-        return memberChain(node.expression);
-    }
-    const parts = [];
-    let cur = node;
-    while (cur.type === 'MemberExpression') {
-        const key = propertyKey(cur.property, cur.computed);
-        if (key === undefined) {
-            return undefined;
-        }
-        parts.unshift(key);
-        cur = cur.object;
-    }
-    return cur.type === 'Identifier' ? { root: cur.name, parts } : undefined;
-}
-function createPathResolver(bindings, contextParam) {
-    function resolveChain(node, resolving) {
-        const chain = memberChain(node);
-        if (!chain) {
-            return undefined;
-        }
-        return [resolveRoot(chain.root, resolving), ...chain.parts].join('.');
-    }
-    function resolveRoot(name, resolving) {
-        if (contextParam !== undefined && name === contextParam) {
-            return 'ctx';
-        }
-        if (bindings.unpinnable.has(name) || resolving.has(name)) {
-            return name;
-        }
-        const decls = bindings.declarations.get(name);
-        if (!decls || decls.length !== 1) {
-            return name;
-        }
-        const [{ kind, init, path }] = decls;
-        if (kind !== 'const' || !init || !path) {
-            return name;
-        }
-        const base = resolveChain(init, new Set(resolving).add(name));
-        return base ? [base, ...path].join('.') : name;
-    }
-    return { pathOf: node => resolveChain(node, new Set()) };
-}
-/** Every `ctx.api.v1.<domain>` the program touches (known or not), through `paths`. */
-function collectApiDomains(program, paths) {
-    const apiDomains = new Set();
-    simple(program, {
-        MemberExpression(node) {
-            const [obj, api, version, domain] = paths.pathOf(node)?.split('.') ?? [];
-            if (obj === 'ctx' && api === 'api' && version === 'v1' && domain) {
-                apiDomains.add(domain);
-            }
-        },
-    });
-    return apiDomains;
-}
-
-export { collectApiDomains, collectBindings, createPathResolver, patternNames };

package/dist/esm/backend/handler-declaration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler-declaration.d.ts","sourceRoot":"","sources":["../../../src/backend/handler-declaration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,UAAU,EACV,mBAAmB,EAEnB,iBAAiB,EAEjB,SAAS,EACV,MAAM,OAAO,CAAC;AAMf,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,CAAC;AAE9D,8DAA8D;AAC9D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,CAAC,SAAS,GAAG,iBAAiB,CAAC,EAAE,GAC/C,kBAAkB,GAAG,SAAS,CAahC;AAED,yGAAyG;AACzG,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,iBAAiB,GAAG,OAAO,CAe3E;AAsCD,mGAAmG;AACnG,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAG3F;AAED,gGAAgG;AAChG,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAK/C,CAAC"}

package/dist/esm/backend/messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/backend/messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;uBACA,MAAM;yBACJ,MAAM;0BACL,MAAM;iCAEC,MAAM;0BAEb,MAAM;6BAEH,MAAM,UAAU,MAAM;wBAE3B,MAAM,QAAQ,MAAM,UAAU,MAAM,UAAU,MAAM;CAEzE,CAAC"}

package/dist/esm/backend/parse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/backend/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8D,KAAK,OAAO,EAAkB,MAAM,OAAO,CAAC;AAkDjH;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAuBhE"}

package/src/backend/__tests__/ast.test.ts

@@ -1,53 +0,0 @@
-import { parse, type ExpressionStatement, type Program } from 'acorn';
-import { describe, expect, it } from 'vitest';
-import { collectBindings, createPathResolver } from '../ast';
-
-const program = (source: string): Program => parse(source, { ecmaVersion: 'latest', sourceType: 'script' });
-
-/** Resolves the expression in the program's last statement. */
-const resolveLast = (source: string, contextParam?: string) => {
-  const p = program(source);
-  const last = p.body[p.body.length - 1] as ExpressionStatement;
-  return createPathResolver(collectBindings(p), contextParam).pathOf(last.expression);
-};
-
-describe('createPathResolver', () => {
-  it('returns the literal chain when nothing is aliased', () => {
-    expect(resolveLast('ctx.api.v1.db.get;')).toBe('ctx.api.v1.db.get');
-  });
-
-  it('treats computed string literals as static keys', () => {
-    expect(resolveLast('ctx.api.v1["db"].get;')).toBe('ctx.api.v1.db.get');
-    expect(resolveLast("const { ['db']: store } = ctx.api.v1; store.get;")).toBe('ctx.api.v1.db.get');
-  });
-
-  it('returns undefined for dynamic links and non-identifier roots', () => {
-    expect(resolveLast('ctx.api.v1[db].get;')).toBeUndefined();
-    expect(resolveLast('fn().db;')).toBeUndefined();
-    expect(resolveLast('"x";')).toBeUndefined();
-  });
-
-  it('rewrites the handler context parameter to ctx', () => {
-    expect(resolveLast('context.api.v1.db.get;', 'context')).toBe('ctx.api.v1.db.get');
-    expect(resolveLast('const sf = context.api.v1.snowflake; sf.query;', 'context')).toBe('ctx.api.v1.snowflake.query');
-  });
-
-  it('follows const aliases, including destructuring and chains', () => {
-    expect(resolveLast('const sf = ctx.api.v1.snowflake; sf.query;')).toBe('ctx.api.v1.snowflake.query');
-    expect(resolveLast('const { v1 } = ctx.api; v1.db;')).toBe('ctx.api.v1.db');
-    expect(resolveLast('const { v1: { db: store } } = ctx.api; store.get;')).toBe('ctx.api.v1.db.get');
-    expect(resolveLast('const a = ctx.api; const b = a.v1; const c = b.db; c;')).toBe('ctx.api.v1.db');
-  });
-
-  it('leaves unpinnable names as written', () => {
-    expect(resolveLast('let sf = ctx.api.v1.snowflake; sf.query;')).toBe('sf.query');
-    expect(resolveLast('const sf = ctx.api.v1.snowflake; sf = 1; sf.query;')).toBe('sf.query');
-    expect(resolveLast('const sf = ctx.api.v1.snowflake; function f(sf) {} sf.query;')).toBe('sf.query');
-    expect(resolveLast('const sf = ctx.api.v1.snowflake; { const sf = 1; } sf.query;')).toBe('sf.query');
-    expect(resolveLast('const [sf] = ctx.api; sf.query;')).toBe('sf.query');
-  });
-
-  it('does not loop on circular aliases', () => {
-    expect(resolveLast('const a = b.x; const b = a.y; a.z;')).toBe('a.y.x.z');
-  });
-});

package/src/backend/ast.ts

@@ -1,201 +0,0 @@
-import type { AnyNode, Expression, Pattern, Program, VariableDeclaration } from 'acorn';
-import { full as walkFull, simple as walkSimple } from 'acorn-walk';
-
-// ─────────── Bindings ───────────
-
-export interface Declaration {
-  kind: VariableDeclaration['kind'];
-  init: Expression | null | undefined;
-  /**
-   * Property path from `init` to this binding: `[]` for `const x = init`,
-   * `['a', 'b']` for `const { a: { b: x } } = init`, `undefined` when the value
-   * is not a plain property read (array/rest/default patterns).
-   */
-  path: string[] | undefined;
-}
-
-export interface Bindings {
-  /** Every `var|let|const <name> = …` in the file, by name. */
-  declarations: Map<string, Declaration[]>;
-  /** Names whose value cannot be pinned: reassigned, updated, or bound as parameters. */
-  unpinnable: Set<string>;
-}
-
-interface PatternBinding {
-  name: string;
-  path: string[] | undefined;
-}
-
-/**
- * Every identifier a binding pattern introduces, with its property path from the
- * pattern's value. `path` is deliberately not defaulted: callers pass `[]` for
- * the root and `undefined` once the pattern stops being a plain property read.
- */
-function patternBindings(pattern: Pattern, path: string[] | undefined): PatternBinding[] {
-  switch (pattern.type) {
-    case 'Identifier':
-      return [{ name: pattern.name, path }];
-    case 'ObjectPattern':
-      return pattern.properties.flatMap(p => {
-        if (p.type === 'RestElement') {
-          return patternBindings(p.argument, undefined);
-        }
-        const key = propertyKey(p.key, p.computed);
-        return patternBindings(p.value, path && key !== undefined ? [...path, key] : undefined);
-      });
-    case 'ArrayPattern':
-      return pattern.elements.flatMap(e => (e ? patternBindings(e, undefined) : []));
-    case 'AssignmentPattern':
-      return patternBindings(pattern.left, undefined);
-    case 'RestElement':
-      return patternBindings(pattern.argument, undefined);
-    default:
-      // MemberExpression targets (`obj.x = …`) bind no names.
-      return [];
-  }
-}
-
-function propertyKey(key: AnyNode, computed: boolean): string | undefined {
-  if (key.type === 'Literal' && typeof key.value === 'string') {
-    return key.value;
-  }
-  if (!computed && key.type === 'Identifier') {
-    return key.name;
-  }
-  return undefined;
-}
-
-/** Every identifier a binding pattern introduces (`{ a, b: [c] } = …` → a, c). */
-export const patternNames = (pattern: Pattern): string[] => patternBindings(pattern, []).map(b => b.name);
-
-export function collectBindings(program: Program): Bindings {
-  const declarations = new Map<string, Declaration[]>();
-  const unpinnable = new Set<string>();
-  const markUnpinnable = (pattern: Pattern) => patternNames(pattern).forEach(n => unpinnable.add(n));
-
-  walkFull(program, node => {
-    switch (node.type) {
-      case 'VariableDeclaration':
-        for (const declarator of node.declarations) {
-          for (const { name, path } of patternBindings(declarator.id, [])) {
-            const list = declarations.get(name) ?? [];
-            list.push({ kind: node.kind, init: declarator.init, path });
-            declarations.set(name, list);
-          }
-        }
-        break;
-      case 'AssignmentExpression':
-        markUnpinnable(node.left);
-        break;
-      case 'UpdateExpression':
-        if (node.argument.type === 'Identifier') {
-          unpinnable.add(node.argument.name);
-        }
-        break;
-      case 'ForInStatement':
-      case 'ForOfStatement':
-        if (node.left.type !== 'VariableDeclaration') {
-          markUnpinnable(node.left);
-        }
-        break;
-      case 'FunctionDeclaration':
-      case 'FunctionExpression':
-      case 'ArrowFunctionExpression':
-        node.params.forEach(markUnpinnable);
-        break;
-      case 'CatchClause':
-        if (node.param) {
-          markUnpinnable(node.param);
-        }
-        break;
-    }
-  });
-
-  return { declarations, unpinnable };
-}
-
-// ─────────── Member paths ───────────
-
-interface MemberChain {
-  root: string;
-  parts: string[];
-}
-
-/** `a.b.c` / `a['b'].c` → root `a`, parts `[b, c]`; `undefined` if any link is dynamic or the root is not an identifier. */
-function memberChain(node: AnyNode): MemberChain | undefined {
-  if (node.type === 'ChainExpression') {
-    return memberChain(node.expression);
-  }
-  const parts: string[] = [];
-  let cur: AnyNode = node;
-  while (cur.type === 'MemberExpression') {
-    const key = propertyKey(cur.property, cur.computed);
-    if (key === undefined) {
-      return undefined;
-    }
-    parts.unshift(key);
-    cur = cur.object;
-  }
-  return cur.type === 'Identifier' ? { root: cur.name, parts } : undefined;
-}
-
-export interface PathResolver {
-  /**
-   * Dotted path of a member chain, following `const` aliases back to their
-   * source: with `const sf = ctx.api.v1.snowflake`, `sf.query` resolves to
-   * `ctx.api.v1.snowflake.query`. Destructuring counts too
-   * (`const { snowflake: sf } = ctx.api.v1`). `undefined` if any link is dynamic.
-   *
-   * Only single, never-reassigned, never-shadowed `const` bindings are followed —
-   * anything else is left as written, so a `let` alias or a parameter of the same
-   * name is never mistaken for the channel. The handler's first parameter is
-   * treated as `ctx` even when renamed (`handler(context)` → `context.api.v1.db`
-   * resolves as `ctx.api.v1.db`).
-   */
-  pathOf(node: AnyNode): string | undefined;
-}
-
-export function createPathResolver(bindings: Bindings, contextParam?: string): PathResolver {
-  function resolveChain(node: AnyNode, resolving: ReadonlySet<string>): string | undefined {
-    const chain = memberChain(node);
-    if (!chain) {
-      return undefined;
-    }
-    return [resolveRoot(chain.root, resolving), ...chain.parts].join('.');
-  }
-
-  function resolveRoot(name: string, resolving: ReadonlySet<string>): string {
-    if (contextParam !== undefined && name === contextParam) {
-      return 'ctx';
-    }
-    if (bindings.unpinnable.has(name) || resolving.has(name)) {
-      return name;
-    }
-    const decls = bindings.declarations.get(name);
-    if (!decls || decls.length !== 1) {
-      return name;
-    }
-    const [{ kind, init, path }] = decls;
-    if (kind !== 'const' || !init || !path) {
-      return name;
-    }
-    const base = resolveChain(init, new Set(resolving).add(name));
-    return base ? [base, ...path].join('.') : name;
-  }
-
-  return { pathOf: node => resolveChain(node, new Set()) };
-}
-
-/** Every `ctx.api.v1.<domain>` the program touches (known or not), through `paths`. */
-export function collectApiDomains(program: Program, paths: PathResolver): Set<string> {
-  const apiDomains = new Set<string>();
-  walkSimple(program, {
-    MemberExpression(node) {
-      const [obj, api, version, domain] = paths.pathOf(node)?.split('.') ?? [];
-      if (obj === 'ctx' && api === 'api' && version === 'v1' && domain) {
-        apiDomains.add(domain);
-      }
-    },
-  });
-  return apiDomains;
-}