@teleporthq/teleport-plugin-next-workflows 0.43.41 → 0.43.44

package/__tests__/raw-sql-param-binding.test.ts

@@ -0,0 +1,138 @@
+import {
+  parameterizeRawSqlInterpolations,
+  parameterizeWorkflowRawSqlInterpolations,
+  parameterizeAllWorkflowRawSql,
+  WorkflowSqlInterpolationError,
+} from '../src/raw-sql-param-binding'
+
+// Generation-time net (runs in the workflows plugin's runBefore). Converts each
+// `{{ name }}` value token in a data node's raw SQL into a positional `$N` +
+// a bound params entry, keeping the published-app runtime on the standard
+// `$N` + params path. PAIRED with the GUI + worker copies.
+
+function ref(nodeId: string, ...path: string[]) {
+  return { type: 'workflowContext' as const, nodeId, path: [nodeId, ...path] }
+}
+
+describe('parameterizeRawSqlInterpolations', () => {
+  it('binds a context-ref variable token in value position', () => {
+    const value = ref('normalize', 'ids')
+    const res = parameterizeRawSqlInterpolations(
+      'DELETE FROM t WHERE id::text = ANY({{ selectedIds }}::text[])',
+      [{ name: 'selectedIds', value }]
+    )
+    expect(res.query).toBe('DELETE FROM t WHERE id::text = ANY($1::text[])')
+    expect(res.params).toEqual([value])
+    expect(res.residuals).toEqual([])
+  })
+
+  it('keeps an unmatched {{state.X}} token as its own string param', () => {
+    const res = parameterizeRawSqlInterpolations(
+      'SELECT * FROM t WHERE owner = {{state.userId}}',
+      []
+    )
+    expect(res.query).toBe('SELECT * FROM t WHERE owner = $1')
+    expect(res.params).toEqual(['{{state.userId}}'])
+  })
+
+  it('reports an identifier-position token as a residual', () => {
+    const res = parameterizeRawSqlInterpolations('SELECT * FROM {{ t }}', [
+      { name: 't', value: ref('n', 't') },
+    ])
+    expect(res.residuals).toEqual(['{{ t }}'])
+    expect(res.params).toEqual([])
+  })
+})
+
+describe('parameterizeWorkflowRawSqlInterpolations', () => {
+  it('rewrites a data-raw-query node and drops queryVariables', () => {
+    const value = ref('n', 'ids')
+    const workflow = {
+      nodes: [
+        {
+          id: 'q',
+          type: 'data-raw-query',
+          config: {
+            query: 'DELETE FROM t WHERE id = ANY({{ ids }}::text[])',
+            queryVariables: [{ name: 'ids', value }],
+          },
+        },
+      ],
+    }
+    parameterizeWorkflowRawSqlInterpolations(workflow)
+    expect(workflow.nodes[0].config).toEqual({
+      query: 'DELETE FROM t WHERE id = ANY($1::text[])',
+      params: [value],
+    })
+  })
+
+  it('rewrites a data-select rawQueryUserPart', () => {
+    const value = ref('n', 'v')
+    const workflow = {
+      nodes: [
+        {
+          id: 's',
+          type: 'data-select',
+          config: {
+            rawQueryUserPart: 'owner_id = {{ v }}',
+            rawQueryUserPartVariables: [{ name: 'v', value }],
+          },
+        },
+      ],
+    }
+    parameterizeWorkflowRawSqlInterpolations(workflow)
+    expect(workflow.nodes[0].config).toEqual({
+      rawQueryUserPart: 'owner_id = $1',
+      rawQueryUserPartParams: [value],
+    })
+  })
+
+  it('throws on an unbindable token and mutates nothing', () => {
+    const workflow = {
+      nodes: [
+        {
+          id: 'bad',
+          type: 'data-raw-query',
+          config: {
+            query: 'SELECT * FROM {{ table }}',
+            queryVariables: [{ name: 'table', value: ref('n', 't') }],
+          },
+        },
+      ],
+    }
+    expect(() => parameterizeWorkflowRawSqlInterpolations(workflow)).toThrow(
+      WorkflowSqlInterpolationError
+    )
+    expect((workflow.nodes[0].config as { query: string }).query).toContain('{{ table }}')
+  })
+})
+
+describe('parameterizeAllWorkflowRawSql', () => {
+  it('walks both workflows and customNodes (id-keyed records)', () => {
+    const value = ref('n', 'ids')
+    const uidlWorkflows = {
+      workflows: {
+        wf1: {
+          nodes: {
+            n1: {
+              type: 'data-raw-query',
+              config: {
+                query: 'DELETE FROM t WHERE id = ANY({{ ids }}::text[])',
+                queryVariables: [{ name: 'ids', value }],
+              },
+            },
+          },
+        },
+      },
+      customNodes: {},
+    }
+    parameterizeAllWorkflowRawSql(uidlWorkflows)
+    const cfg = uidlWorkflows.workflows.wf1.nodes.n1.config as { query: string; params: unknown[] }
+    expect(cfg.query).toBe('DELETE FROM t WHERE id = ANY($1::text[])')
+    expect(cfg.params).toEqual([value])
+  })
+
+  it('is a no-op when workflows is undefined', () => {
+    expect(() => parameterizeAllWorkflowRawSql(undefined)).not.toThrow()
+  })
+})

package/__tests__/route-changed-trigger.test.ts

@@ -0,0 +1,106 @@
+// `event-route-changed` codegen: component-scoped triggers register a
+// `Router.events` listener inside the owning component's lifecycle effect
+// (with an `.off` cleanup so remounts don't leak listeners); unbound triggers
+// are global-scoped and register in the `_app`-mounted global workflows hook,
+// which must then import Router itself.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+import { NextWorkflowProjectPlugin } from '../src/workflow-project-plugin'
+
+const routeChangedWorkflow = (scope: string, config: Record<string, unknown>) => ({
+  id: 'wf-route-changed',
+  name: 'Track Route',
+  trigger: {
+    type: 'event-route-changed',
+    nodeId: 'trigger-route-changed',
+    scope,
+    config,
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'currentRoute', value: '' },
+      stepNumber: 1,
+      label: 'Set route',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-route-changed', target: 'update-1' }],
+})
+
+const jsxComponentChunk = () => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'BlockStatement',
+            body: [{ type: 'ReturnStatement', argument: null }],
+          },
+        },
+      },
+    ],
+  },
+})
+
+describe('event-route-changed — component scope', () => {
+  it('registers Router.events with an .off cleanup in the component lifecycle', async () => {
+    const workflow = routeChangedWorkflow('component', { componentName: 'Navigation' })
+    const plugin = createNextWorkflowPlugin({ isPage: false })
+    const structure: any = {
+      uidl: {
+        name: 'Navigation',
+        node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+        stateDefinitions: { currentRoute: { type: 'string', defaultValue: '' } },
+      },
+      chunks: [jsxComponentChunk()],
+      options: {
+        workflows: { workflows: { [workflow.id]: workflow }, customNodes: {} },
+      },
+      dependencies: {},
+    }
+    await plugin(structure)
+    const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+    expect(moduleChunk).toBeDefined()
+    const code = String(moduleChunk.content)
+    expect(code).toContain("Router.events.on('routeChangeComplete'")
+    expect(code).toContain("Router.events.off('routeChangeComplete'")
+    expect(code).toContain('cleanups.push')
+    expect(code).toContain('previousUrl')
+  })
+})
+
+describe('event-route-changed — global scope', () => {
+  const plugin = new NextWorkflowProjectPlugin()
+  // generateGlobalWorkflowsHook is private; call it directly for a unit test.
+  const code = (plugin as any).generateGlobalWorkflowsHook([
+    routeChangedWorkflow('global', {}),
+  ]) as string
+
+  it('registers Router.events with an .off cleanup in the global hook', () => {
+    expect(code).toContain("Router.events.on('routeChangeComplete'")
+    expect(code).toContain("Router.events.off('routeChangeComplete'")
+    expect(code).toContain('previousUrl')
+  })
+
+  it('imports Router in the generated global-workflows file', () => {
+    expect(code).toContain("import Router from 'next/router';")
+  })
+
+  it('does NOT import Router when no route-changed workflow exists', () => {
+    const withoutRoute = (plugin as any).generateGlobalWorkflowsHook([
+      {
+        id: 'wf-other',
+        trigger: { type: 'event-user-logged-in', config: {} },
+        nodes: [],
+        edges: [],
+      },
+    ]) as string
+    expect(withoutRoute).not.toContain("import Router from 'next/router';")
+  })
+})

package/__tests__/state-update-missing-setter-warn.test.ts

@@ -0,0 +1,180 @@
+// `__stateUpdateHandler` observability guard: writing to a state property the
+// current page/component does NOT own must console.warn (and still resolve)
+// instead of silently no-oping. The silent no-op masked the original
+// "Auto-open Navigation Sidebar Group" bug for weeks: the workflow ran on
+// every page, found no `sidebarGroupOpen` setter, and did nothing without a
+// trace. Harness mirrors state-update-default-value.test.ts.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const extractFunctionSource = (haystack: string, funcDecl: string): string => {
+  const startIdx = haystack.indexOf(funcDecl)
+  if (startIdx === -1) {
+    throw new Error('Helper not found: ' + funcDecl)
+  }
+  return braceMatchFrom(haystack, startIdx)
+}
+
+const braceMatchFrom = (haystack: string, startIdx: number): string => {
+  let depth = 0
+  let i = haystack.indexOf('{', startIdx)
+  if (i === -1) {
+    throw new Error('No opening brace from index ' + startIdx)
+  }
+  for (; i < haystack.length; i++) {
+    const ch = haystack.charAt(i)
+    if (ch === '{') {
+      depth++
+    } else if (ch === '}') {
+      depth--
+      if (depth === 0) {
+        return haystack.slice(startIdx, i + 1)
+      }
+    }
+  }
+  throw new Error('Unbalanced braces from index ' + startIdx)
+}
+
+const buildStructure = (): any => ({
+  uidl: {
+    name: 'Page',
+    outputOptions: { pageId: 'page-1', fileName: 'page-1' },
+    node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+    stateDefinitions: { known: { type: 'string', defaultValue: '' } },
+  },
+  chunks: [
+    {
+      type: 'chunk-type-ast',
+      name: 'jsx-component',
+      content: {
+        type: 'VariableDeclaration',
+        declarations: [
+          {
+            type: 'VariableDeclarator',
+            init: {
+              type: 'ArrowFunctionExpression',
+              body: {
+                type: 'BlockStatement',
+                body: [{ type: 'ReturnStatement', argument: null }],
+              },
+            },
+          },
+        ],
+      },
+    },
+  ],
+  options: {
+    workflows: {
+      workflows: {
+        'wf-1': {
+          id: 'wf-1',
+          name: 'Test WF',
+          trigger: {
+            type: 'event-page-loaded',
+            nodeId: 'trigger-1',
+            scope: 'page',
+            config: { pageId: 'page-1' },
+          },
+          nodes: [
+            {
+              id: 'update-1',
+              type: 'state-update-local-state',
+              config: { property: 'known', value: 'x' },
+              stepNumber: 1,
+              label: 'X',
+            },
+          ],
+          edges: [{ id: 'e', source: 'trigger-1', target: 'update-1' }],
+        },
+      },
+      customNodes: {},
+    },
+  },
+  dependencies: {},
+})
+
+type HandlerFn = (config: any, context: any) => Promise<any>
+
+const buildUpdateHandler = async (
+  stateTypes: Record<string, string>
+): Promise<{ update: HandlerFn; writes: Record<string, unknown> }> => {
+  const plugin = createNextWorkflowPlugin({ isPage: true })
+  const structure = buildStructure()
+  await plugin(structure as any)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  if (!moduleChunk) {
+    throw new Error('workflow-module chunk not emitted by plugin')
+  }
+  const moduleCode = String(moduleChunk.content)
+
+  const coerceSrc = extractFunctionSource(moduleCode, 'function __coerceValue')
+  const defaultSrc = extractFunctionSource(moduleCode, 'function __defaultValueForType')
+  const updateSrc = extractFunctionSource(moduleCode, 'function __stateUpdateHandler')
+
+  const writes: Record<string, unknown> = {}
+  const stateSetters: Record<string, (v: unknown) => void> = {}
+  for (const key of Object.keys(stateTypes)) {
+    stateSetters[key] = (v: unknown) => {
+      writes[key] = v
+    }
+  }
+  const stateValuesRef = { current: {} as Record<string, unknown> }
+
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const factory = new Function(
+    'stateSetters',
+    'stateTypes',
+    'stateValuesRef',
+    `
+    var __stateNameMap = {};
+    Object.keys(stateSetters).forEach(function(k) { __stateNameMap[k] = k; });
+    function __resolveName(name) { return __stateNameMap[name] || name; }
+    ${coerceSrc}
+    ${defaultSrc}
+    ${updateSrc}
+    return __stateUpdateHandler;
+    `
+  )
+  const update = factory(stateSetters, stateTypes, stateValuesRef) as HandlerFn
+  return { update, writes }
+}
+
+describe('state-update with a missing setter', () => {
+  let warnSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+  })
+
+  afterEach(() => {
+    warnSpy.mockRestore()
+  })
+
+  it('warns and still resolves for a plain-value update', async () => {
+    const { update, writes } = await buildUpdateHandler({ known: 'string' })
+    const result = await update({ property: 'unknownProp', value: 'x' }, { __stateValues: {} })
+    expect(result.success).toBe(true)
+    expect(writes.unknownProp).toBeUndefined()
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    expect(String(warnSpy.mock.calls[0][0])).toContain('unknownProp')
+    expect(String(warnSpy.mock.calls[0][0])).toContain('known')
+  })
+
+  it('warns and still resolves for an object property-mode update', async () => {
+    const { update } = await buildUpdateHandler({ known: 'string' })
+    const result = await update(
+      { property: 'unknownObj', objectUpdateMode: 'property', objectPropertyPath: 'a', value: 1 },
+      { __stateValues: {} }
+    )
+    expect(result.success).toBe(true)
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    expect(String(warnSpy.mock.calls[0][0])).toContain('unknownObj')
+  })
+
+  it('does NOT warn when the setter exists', async () => {
+    const { update, writes } = await buildUpdateHandler({ known: 'string' })
+    await update({ property: 'known', value: 'hello' }, { __stateValues: {} })
+    expect(writes.known).toBe('hello')
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+})

package/dist/cjs/account-delete-route-generator.d.ts

@@ -0,0 +1,13 @@
+export interface AccountDeleteRouteOptions {
+    authUsersTableName?: string;
+    emailProvider?: string | null;
+    fromEmail?: string;
+    emailSecretEnvName?: string | null;
+    emailSubject?: string;
+    emailBodyHtml?: string;
+    siteName?: string;
+    deletedEmailPattern?: string;
+}
+export declare const accountDeleteRouteDependencies: (provider?: string) => Record<string, string>;
+export declare const generateAccountDeleteRoute: (options?: AccountDeleteRouteOptions) => string;
+//# sourceMappingURL=account-delete-route-generator.d.ts.map

package/dist/cjs/account-delete-route-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-delete-route-generator.d.ts","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAI3B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAID,eAAO,MAAM,8BAA8B,+CAAiC,CAAA;AAE5E,eAAO,MAAM,0BAA0B,aAAa,yBAAyB,KAAQ,MA6NpF,CAAA"}

package/dist/cjs/account-delete-route-generator.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAccountDeleteRoute = exports.accountDeleteRouteDependencies = void 0;
+/**
+ * Generates the dedicated API route that backs the `account-delete-current`
+ * workflow node: `pages/api/account/delete-current.js`.
+ *
+ * The client node calls this route, which:
+ *   1. resolves the current user from the NextAuth session (never trusting a
+ *      client-supplied id),
+ *   2. runs a single DB transaction that detaches + anonymises business/legal
+ *      records (orders, withdrawal requests) so tracking survives, deletes the
+ *      user's personal data (reviews, cart, favourites, chat history) and the
+ *      user row, and
+ *   3. best-effort sends the farewell email (a failed send never fails the
+ *      deletion).
+ *
+ * Every table statement is guarded by a runtime `information_schema` column
+ * check, so the route is a no-op for feature tables a given project never
+ * provisioned.
+ */
+const pg_client_code_1 = require("./pg-client-code");
+const transactional_email_code_1 = require("./transactional-email-code");
+// Kept as a named alias (imported by workflow-project-plugin.ts) so the delete
+// route's dependency wiring stays stable while the impl lives in the shared module.
+exports.accountDeleteRouteDependencies = transactional_email_code_1.transactionalEmailDependencies;
+const generateAccountDeleteRoute = (options = {}) => {
+    const authUsersTable = options.authUsersTableName || 'users';
+    const provider = options.emailProvider && transactional_email_code_1.SUPPORTED_EMAIL_PROVIDERS.has(options.emailProvider)
+        ? options.emailProvider
+        : null;
+    const deletedEmailPattern = options.deletedEmailPattern || 'deleted-user-{{userId}}@deleted.invalid';
+    return `${(0, pg_client_code_1.generatePgClientCode)()}
+const { getToken } = require('next-auth/jwt');
+
+const AUTH_USERS_TABLE = ${JSON.stringify(authUsersTable)};
+const SITE_NAME = ${JSON.stringify(options.siteName || '')};
+const DELETED_EMAIL_PATTERN = ${JSON.stringify(deletedEmailPattern)};
+const EMAIL_PROVIDER = ${JSON.stringify(provider)};
+const EMAIL_FROM = ${JSON.stringify(options.fromEmail || '')};
+const EMAIL_SECRET_ENV_NAME = ${JSON.stringify(options.emailSecretEnvName || '')};
+const EMAIL_SUBJECT = ${JSON.stringify(options.emailSubject || 'Your account has been deleted')};
+const EMAIL_BODY_HTML = ${JSON.stringify(options.emailBodyHtml || '')};
+
+// Personal data owned by the user — rows are DELETED (keyed by user_id). Messages
+// are deleted before conversations so a conversation delete only cascades leftovers.
+const DELETE_TABLES = [
+  'teleport_product_reviews',
+  'teleport_favourites',
+  'teleport_cart',
+  'teleport_ai_chat_messages',
+  'teleport_ai_chat_conversations',
+];
+// Business / legal records that must survive: the user link is nulled and any
+// stored personal email is replaced with a synthetic, self-describing address.
+const ANONYMIZE_TABLES = ['teleport_orders', 'teleport_withdrawal_requests'];
+const EMAIL_COLUMNS = ['billing_email', 'shipping_email', 'customer_email', 'email'];
+
+async function tableColumns(client, table) {
+  var r = await client.query(
+    "SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1",
+    [table]
+  );
+  var cols = [];
+  for (var i = 0; i < r.rows.length; i++) { cols.push(r.rows[i].column_name); }
+  return cols;
+}
+
+async function anonymizeUserRows(client, table, userId, syntheticEmail) {
+  var cols = await tableColumns(client, table);
+  if (cols.indexOf('user_id') === -1) { return; }
+  var sets = ['user_id = NULL'];
+  var params = [userId];
+  for (var i = 0; i < EMAIL_COLUMNS.length; i++) {
+    if (cols.indexOf(EMAIL_COLUMNS[i]) !== -1) {
+      params.push(syntheticEmail);
+      sets.push(EMAIL_COLUMNS[i] + ' = $' + params.length);
+    }
+  }
+  await client.query('UPDATE ' + table + ' SET ' + sets.join(', ') + ' WHERE user_id = $1', params);
+}
+
+async function deleteUserRows(client, table, userId) {
+  var cols = await tableColumns(client, table);
+  if (cols.indexOf('user_id') === -1) { return; }
+  await client.query('DELETE FROM ' + table + ' WHERE user_id = $1', [userId]);
+}
+
+async function deleteRowsByEmail(client, table, column, email) {
+  if (!email) { return; }
+  var cols = await tableColumns(client, table);
+  if (cols.indexOf(column) === -1) { return; }
+  await client.query('DELETE FROM ' + table + ' WHERE ' + column + ' = $1', [email]);
+}
+
+// Invoices are a financial/tax record that must survive, but they store the
+// customer's PII denormalised and link to the user only through order_id (no
+// user_id). Scrub the PII in place, matching invoices whose order belongs to the
+// user. MUST run BEFORE the orders row is anonymised (its user_id is still set).
+var INVOICE_PII_NULL_COLUMNS = [
+  'customer_name',
+  'customer_address',
+  'customer_city',
+  'customer_state',
+  'customer_zip',
+  'customer_country',
+  'customer_vat',
+  'customer_phone',
+];
+
+async function anonymizeInvoices(client, ordersTable, invoicesTable, userId, syntheticEmail) {
+  var invCols = await tableColumns(client, invoicesTable);
+  if (invCols.indexOf('order_id') === -1) { return; }
+  var orderCols = await tableColumns(client, ordersTable);
+  if (orderCols.indexOf('user_id') === -1) { return; }
+  var sets = [];
+  var params = [];
+  if (invCols.indexOf('customer_email') !== -1) {
+    params.push(syntheticEmail);
+    sets.push('customer_email = $' + params.length);
+  }
+  for (var i = 0; i < INVOICE_PII_NULL_COLUMNS.length; i++) {
+    if (invCols.indexOf(INVOICE_PII_NULL_COLUMNS[i]) !== -1) {
+      sets.push(INVOICE_PII_NULL_COLUMNS[i] + ' = NULL');
+    }
+  }
+  if (sets.length === 0) { return; }
+  params.push(userId);
+  await client.query(
+    'UPDATE ' + invoicesTable + ' SET ' + sets.join(', ') +
+      ' WHERE order_id IN (SELECT id FROM ' + ordersTable + ' WHERE user_id = $' + params.length + ')',
+    params
+  );
+}
+
+${(0, transactional_email_code_1.generateFillTemplateFn)()}
+
+${(0, transactional_email_code_1.generateProviderSendFunction)(provider)}
+
+async function sendFarewellEmail(toEmail, tokenValues) {
+  if (!EMAIL_PROVIDER || !EMAIL_BODY_HTML || !toEmail) { return; }
+  var apiKey = EMAIL_SECRET_ENV_NAME ? process.env[EMAIL_SECRET_ENV_NAME] : '';
+  // Don't treat an unresolved deploy placeholder as a real credential.
+  if (apiKey && String(apiKey).indexOf('teleporthq.secrets.') === 0) { apiKey = ''; }
+  if (!apiKey) { console.warn('[account-delete] farewell email skipped: credential not set'); return; }
+  var from = EMAIL_FROM || process.env.EMAIL_FROM || '';
+  if (!from) { console.warn('[account-delete] farewell email skipped: sender not configured'); return; }
+  var subject = fillTemplate(EMAIL_SUBJECT, tokenValues);
+  var html = fillTemplate(EMAIL_BODY_HTML, tokenValues);
+  await __sendProviderEmail({ from: from, to: toEmail, subject: subject, html: html, apiKey: apiKey });
+}
+
+module.exports = async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  // Identify the user from the session — never trust a client-supplied id.
+  var token = null;
+  try {
+    token = await getToken({ req: req, secret: process.env.NEXTAUTH_SECRET });
+  } catch (e) {
+    token = null;
+  }
+  var userId = token && (token.id || token.sub);
+  if (!userId) {
+    return res.status(401).json({ error: 'Unauthenticated' });
+  }
+
+  var client = getClient();
+  var userEmail = '';
+  var userName = '';
+  var userFound = false;
+  var failed = false;
+  // try/finally so the pg connection is ALWAYS closed — every early exit
+  // (not-found, error) leaves via the finally, never leaking a connection.
+  try {
+    await client.connect();
+
+    // Capture the email/name BEFORE deletion so the farewell email can still be sent.
+    var userRes = await client.query('SELECT * FROM ' + AUTH_USERS_TABLE + ' WHERE id = $1', [userId]);
+    if (userRes.rows.length) {
+      userFound = true;
+      userEmail = userRes.rows[0].email || '';
+      userName = userRes.rows[0].name || '';
+
+      var syntheticEmail = String(DELETED_EMAIL_PATTERN).split('{{userId}}').join(String(userId));
+
+      await client.query('BEGIN');
+      try {
+        // Scrub invoice PII FIRST — invoices link to the user only through
+        // order_id, so this must run while the orders row still carries user_id.
+        await anonymizeInvoices(client, 'teleport_orders', 'teleport_invoices', userId, syntheticEmail);
+        for (var a = 0; a < ANONYMIZE_TABLES.length; a++) {
+          await anonymizeUserRows(client, ANONYMIZE_TABLES[a], userId, syntheticEmail);
+        }
+        for (var d = 0; d < DELETE_TABLES.length; d++) {
+          await deleteUserRows(client, DELETE_TABLES[d], userId);
+        }
+        // password_reset_tokens has no user_id — it is keyed by the email string.
+        await deleteRowsByEmail(client, 'password_reset_tokens', 'email', userEmail);
+        await client.query('DELETE FROM ' + AUTH_USERS_TABLE + ' WHERE id = $1', [userId]);
+        await client.query('COMMIT');
+      } catch (txErr) {
+        try { await client.query('ROLLBACK'); } catch (e) {}
+        throw txErr;
+      }
+    }
+  } catch (err) {
+    failed = true;
+    console.error('[account-delete] failed:', err && err.message ? err.message : err);
+  } finally {
+    try { await client.end(); } catch (e) {}
+  }
+
+  if (failed) {
+    return res.status(500).json({ error: 'Account deletion failed' });
+  }
+  if (!userFound) {
+    return res.status(404).json({ error: 'Account not found' });
+  }
+
+  // Best-effort farewell email AFTER the successful commit (connection closed).
+  try {
+    var resolvedSiteName =
+      SITE_NAME ||
+      (req.headers && req.headers.host
+        ? String(req.headers.host).replace(/^www\\./, '').split(':')[0]
+        : '');
+    await sendFarewellEmail(userEmail, {
+      userName: userName || 'there',
+      userEmail: userEmail,
+      siteName: resolvedSiteName,
+    });
+  } catch (emailErr) {
+    console.error(
+      '[account-delete] farewell email failed:',
+      emailErr && emailErr.message ? emailErr.message : emailErr
+    );
+  }
+
+  return res.status(200).json({ success: true });
+};
+`;
+};
+exports.generateAccountDeleteRoute = generateAccountDeleteRoute;
+//# sourceMappingURL=account-delete-route-generator.js.map