@teleporthq/teleport-plugin-next-workflows 0.43.62 → 0.43.63

package/__tests__/data-update-item-runtime.test.ts

@@ -99,6 +99,45 @@ describe('data-update-item runtime output + null-safety', () => {
     expect(result.affected).toBe(0)
   })
 
+  /*
+    A value that could not cross the client→server hand-off arrives as the
+    pruner's placeholder. Written through, it REPLACES the stored content with
+    `{"__truncated":true}` — which is how a rich-text field carrying an inlined
+    image emptied a whole custom page's block tree. The column keeps what it has
+    instead, exactly like an undefined mapping.
+  */
+  it('keeps the stored value when the new one arrived truncated', async () => {
+    const calls = installFetch({ id: 'r1', updatedCount: 1 })
+    await handler(
+      {
+        tableName: 'teleport_pages',
+        filters: [{ field: 'id', operator: '=', value: 'p1' }],
+        columnMappings: [
+          { column: 'blocks', value: { __truncated: true, type: 'string' } },
+          { column: 'title', value: 'Launch' },
+        ],
+      },
+      {}
+    )
+    expect(calls).toHaveLength(1)
+    const sentMappings = calls[0].body.columnMappings as Array<{ column: string }>
+    expect(sentMappings.map((m) => m.column)).toEqual(['title'])
+  })
+
+  it('keeps the stored value when the new one could not be serialized', async () => {
+    const calls = installFetch({ id: 'r1', updatedCount: 1 })
+    const result = (await handler(
+      {
+        tableName: 'teleport_pages',
+        filters: [{ field: 'id', operator: '=', value: 'p1' }],
+        columnMappings: { blocks: { __serializationError: true } },
+      },
+      {}
+    )) as Record<string, unknown>
+    expect(calls).toHaveLength(0)
+    expect(result.updatedCount).toBe(0)
+  })
+
   it('preserves an explicit null columnMapping (intentional clear ≠ undefined)', async () => {
     const calls = installFetch({ id: 'r1', updatedCount: 1 })
     await handler(

package/__tests__/page-revalidate-node.test.ts

@@ -0,0 +1,276 @@
+import { nodeRegistry } from '../src'
+
+interface RevalidateResult {
+  revalidated?: string[]
+  warning?: string
+  success?: boolean
+  error?: unknown
+}
+
+interface FetchCall {
+  url: string
+  init: {
+    method: string
+    headers: Record<string, string>
+    body: string
+  }
+}
+
+const source = () => nodeRegistry['page-revalidate'].generateHandler()
+
+/**
+ * Runs the emitted handler the way the generated app does: as runtime source in
+ * a scope that provides only `globalThis`, `window` and `fetch`. `process` is
+ * reached through the injected `globalThis`, which is exactly how the handler
+ * has to read it to survive the browser webpack.
+ */
+const runHandler = async (
+  config: Record<string, unknown>,
+  options: {
+    secret?: string
+    context?: Record<string, unknown>
+    // tslint:disable-next-line:no-any
+    respond?: (call: FetchCall) => any
+    calls?: FetchCall[]
+  } = {}
+): Promise<RevalidateResult> => {
+  const env = options.secret === undefined ? {} : { TQ_CACHE_SECRET: options.secret }
+  const calls = options.calls || []
+
+  // tslint:disable-next-line:no-any
+  const fetchImpl = async (url: string, init: any) => {
+    const call: FetchCall = { url, init }
+    calls.push(call)
+    if (!options.respond) {
+      throw new Error('offline')
+    }
+    const payload = options.respond(call)
+    return {
+      ok: payload.ok !== false,
+      json: async () => payload.body,
+    }
+  }
+
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(
+    'globalThis',
+    'window',
+    'fetch',
+    `${source()}; return page_revalidate;`
+  )
+  const fn = factory({ process: { env } }, undefined, fetchImpl)
+
+  return fn(config, options.context || { __baseUrl: 'https://site.test' })
+}
+
+const expectNotFatal = (result: RevalidateResult) => {
+  // Mirrors `isFatalNodeResult` in the emitted runtime: `success: false`, a
+  // string `error`, or `error: true` HALTS the workflow.
+  expect(result.success).toBeUndefined()
+  expect(typeof result.error).not.toBe('string')
+  expect(result.error).not.toBe(true)
+}
+
+describe('page-revalidate node', () => {
+  it('is registered and runs on the server', () => {
+    expect(nodeRegistry['page-revalidate']).toBeDefined()
+    expect(nodeRegistry['page-revalidate'].nodeType).toBe('page-revalidate')
+    // `res.revalidate` only exists inside a server route, and server-side puts
+    // the rebuild in the same segment as the write it follows.
+    expect(nodeRegistry['page-revalidate'].executionEnv).toBe('server')
+  })
+
+  /**
+   * Handlers ship as runtime source and are re-bundled by webpack, which
+   * rewrites `require(`.
+   */
+  it('never requires a module', () => {
+    expect(source()).not.toMatch(/(?<![\w.])require\s*\(/)
+  })
+
+  describe('path resolution', () => {
+    it('posts the configured paths to the revalidate route', async () => {
+      const calls: FetchCall[] = []
+      const result = await runHandler(
+        { paths: ['/pages/welcome', '/pages/about'] },
+        {
+          secret: 'sekret',
+          calls,
+          respond: () => ({ body: { ok: true, revalidated: ['/pages/welcome'], failed: [] } }),
+        }
+      )
+
+      expect(calls).toHaveLength(1)
+      expect(calls[0].url).toBe('https://site.test/api/tq-revalidate')
+      expect(calls[0].init.method).toBe('POST')
+      expect(calls[0].init.headers['x-tq-cache-secret']).toBe('sekret')
+      expect(JSON.parse(calls[0].init.body)).toEqual({
+        paths: ['/pages/welcome', '/pages/about'],
+      })
+      expect(result.revalidated).toEqual(['/pages/welcome'])
+      expect(result.warning).toBeUndefined()
+    })
+
+    /**
+     * A path built from a database column routinely arrives as the bare slug,
+     * and `res.revalidate` only accepts a site-root-relative path.
+     */
+    it('gives a bare slug a leading slash', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: ['pages/welcome'] },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual(['/pages/welcome'])
+    })
+
+    /**
+     * An update revalidates the slug the row HAD and the slug it now has — and
+     * when the slug did not change, those are the same string. Rebuilding it
+     * twice would double the work for no effect.
+     */
+    it('drops blanks, unresolved refs and duplicates', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        {
+          paths: [
+            '/pages/welcome',
+            '  ',
+            '/pages/welcome',
+            null,
+            { type: 'workflowContext', nodeId: 'n1', path: ['value'] },
+            'pages/welcome',
+          ],
+        },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual(['/pages/welcome'])
+    })
+
+    /*
+     * A step that rebuilds several rows at once resolves ONE reference to an
+     * array of slugs — a bulk delete cannot know at build time how many rows the
+     * admin will select, so it cannot configure a path per row.
+     */
+    it('flattens an array of paths resolved from a single reference', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: [['/pages/welcome', '/pages/pricing'], '/pages/about'] },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual([
+        '/pages/welcome',
+        '/pages/pricing',
+        '/pages/about',
+      ])
+    })
+
+    it('accepts a single path configured as a bare string', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: '/pages/welcome' },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual(['/pages/welcome'])
+    })
+
+    it('forwards the internal request headers the deployment protection needs', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: ['/pages/welcome'] },
+        {
+          secret: 'sekret',
+          calls,
+          context: {
+            __baseUrl: 'https://site.test',
+            __internalHeaders: { cookie: '_vercel_jwt=abc' },
+          },
+          respond: () => ({ body: { ok: true } }),
+        }
+      )
+
+      expect(calls[0].init.headers.cookie).toBe('_vercel_jwt=abc')
+    })
+  })
+
+  /**
+   * THE regression this node is shaped around. The runtime treats
+   * `success: false` / a string `error` as FATAL, so a page that could not be
+   * rebuilt would halt the workflow AFTER the row was already written — no
+   * success toast, no navigation, and an error for an action that worked. Every
+   * failure mode below has to report a warning instead.
+   */
+  describe('never reports failure in a shape the runtime treats as fatal', () => {
+    it('with no paths configured', async () => {
+      const calls: FetchCall[] = []
+      const result = await runHandler({}, { secret: 'sekret', calls })
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toContain('No page paths')
+      expect(calls).toHaveLength(0)
+      expectNotFatal(result)
+    })
+
+    it('with every configured path blank', async () => {
+      const result = await runHandler({ paths: ['', '   '] }, { secret: 'sekret' })
+
+      expect(result.revalidated).toEqual([])
+      expectNotFatal(result)
+    })
+
+    it('with no secret configured', async () => {
+      const calls: FetchCall[] = []
+      const result = await runHandler({ paths: ['/pages/welcome'] }, { calls })
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toContain('TQ_CACHE_SECRET')
+      // Nothing is sent without the credential the route requires.
+      expect(calls).toHaveLength(0)
+      expectNotFatal(result)
+    })
+
+    it('when the route answers with an error status', async () => {
+      const result = await runHandler(
+        { paths: ['/pages/welcome'] },
+        { secret: 'sekret', respond: () => ({ ok: false, body: { error: 'Unauthorized' } }) }
+      )
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toBe('Unauthorized')
+      expectNotFatal(result)
+    })
+
+    it('when the route is unreachable', async () => {
+      const result = await runHandler({ paths: ['/pages/welcome'] }, { secret: 'sekret' })
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toBe('offline')
+      expectNotFatal(result)
+    })
+
+    /**
+     * `res.revalidate` throws for a path that was never statically generated —
+     * the normal case for a page whose row was just deleted. The paths that DID
+     * rebuild are still reported.
+     */
+    it('when some paths could not be rebuilt', async () => {
+      const result = await runHandler(
+        { paths: ['/pages/welcome', '/pages/gone'] },
+        {
+          secret: 'sekret',
+          respond: () => ({
+            body: { ok: true, revalidated: ['/pages/welcome'], failed: ['/pages/gone'] },
+          }),
+        }
+      )
+
+      expect(result.revalidated).toEqual(['/pages/welcome'])
+      expect(result.warning).toContain('/pages/gone')
+      expectNotFatal(result)
+    })
+  })
+})

package/__tests__/payment-refund.test.ts

@@ -0,0 +1,135 @@
+import { loadHandler, HandlerFn } from './_helpers/load-handler'
+import { paymentRefund } from '../src/nodes/payment/payment-refund'
+import { resolveHandlerEntryName } from '../src/nodes/types'
+import { collectSecrets } from '../src/secret-collector'
+
+interface RefundResult {
+  success: boolean
+  refundId: string
+  amount: number
+  currency: string
+  status: string
+  error: string
+}
+
+describe('payment-refund', () => {
+  const handler: HandlerFn = loadHandler('payment-refund')
+  const source = paymentRefund.generateHandler()
+
+  it('is a SERVER node that continues the workflow', () => {
+    expect(paymentRefund.executionEnv).toBe('server')
+    // Unlike a charge, a refund must NOT be terminal: the steps that record it,
+    // restock it and email the buyer all run after it.
+    expect(paymentRefund.isTerminal).toBe(false)
+  })
+
+  it('has its provider credentials collected into the generated env', () => {
+    // Without this the exported project ships with no key for the refund node
+    // and every refund fails at runtime with "not configured".
+    const secrets = collectSecrets({
+      workflows: {
+        wf1: {
+          nodes: [
+            {
+              id: 'node-1',
+              type: 'payment-refund',
+              config: { secretKey: 'sk_test_1', clientId: 'id_1', clientSecret: 'cs_1' },
+            },
+          ],
+        },
+      },
+    } as never)
+    expect(secrets.map((secret) => secret.fieldName).sort()).toEqual([
+      'clientId',
+      'clientSecret',
+      'secretKey',
+    ])
+  })
+
+  it('resolves its own entry point out of the concatenated source', () => {
+    // The entry has to be the FIRST statement-level two-parameter function, or
+    // the generated route calls a helper instead.
+    expect(resolveHandlerEntryName(source, 'payment-refund')).toBe('payment_refund')
+  })
+
+  it('reads process through globalThis, which webpack leaves alone', () => {
+    // A bare `process` is rewritten by the GUI's browser packer into a name
+    // that does not exist on the Vercel Node runtime.
+    expect(source).toContain('globalThis.process.env')
+    // …and nowhere is `process.env` read WITHOUT that prefix.
+    expect(source.replace(/globalThis\.process\.env/g, '')).not.toContain('process.env')
+  })
+
+  it('keeps each currency list in the SAME snapshot as the code that reads it', () => {
+    // A declaration in one `.toString()`'d function and its reference in
+    // another is the "Oo is not defined" bug — a minifier renames the two
+    // independently and the generated file references a name it never declares.
+    // Slicing the emitted source per function is the only way to check that.
+    for (const fnName of ['toProviderMinorUnits', 'fromProviderMinorUnits']) {
+      const start = source.indexOf(`function ${fnName}`)
+      expect(start).toBeGreaterThanOrEqual(0)
+      const next = source.indexOf('\nfunction ', start + 1)
+      const body = next === -1 ? source.slice(start) : source.slice(start, next)
+      expect(body).toContain('zeroDecimalCurrencies = [')
+      expect(body).toContain('threeDecimalCurrencies = [')
+      expect(body).toContain('zeroDecimalCurrencies.indexOf')
+    }
+  })
+
+  it('refuses without a payment reference instead of calling a provider', async () => {
+    const result = (await handler({ currency: 'usd' }, {})) as RefundResult
+    expect(result.success).toBe(false)
+    expect(result.error).toMatch(/no payment reference/i)
+    expect(result.refundId).toBe('')
+  })
+
+  it('reports missing Stripe credentials as an actionable error', async () => {
+    const saved = process.env.STRIPE_SECRET_KEY
+    delete process.env.STRIPE_SECRET_KEY
+    try {
+      const result = (await handler(
+        { providerType: 'stripe', paymentReference: 'pi_1', currency: 'usd' },
+        {}
+      )) as RefundResult
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('STRIPE_SECRET_KEY')
+      // The shape stays constant on every path, so a downstream node can bind
+      // to it without knowing which branch ran.
+      expect(result).toMatchObject({ refundId: '', amount: 0, status: '' })
+    } finally {
+      if (saved !== undefined) {
+        process.env.STRIPE_SECRET_KEY = saved
+      }
+    }
+  })
+
+  it('reports missing PayPal credentials without attempting a network call', async () => {
+    const savedId = process.env.PAYPAL_CLIENT_ID
+    const savedSecret = process.env.PAYPAL_CLIENT_SECRET
+    delete process.env.PAYPAL_CLIENT_ID
+    delete process.env.PAYPAL_CLIENT_SECRET
+    try {
+      const result = (await handler(
+        { providerType: 'paypal', paymentReference: 'cap_1', currency: 'usd' },
+        {}
+      )) as RefundResult
+      expect(result.success).toBe(false)
+      expect(result.error).toMatch(/PayPal credentials are not configured/i)
+    } finally {
+      if (savedId !== undefined) {
+        process.env.PAYPAL_CLIENT_ID = savedId
+      }
+      if (savedSecret !== undefined) {
+        process.env.PAYPAL_CLIENT_SECRET = savedSecret
+      }
+    }
+  })
+
+  it('always returns an answer rather than throwing, so bookkeeping can still run', async () => {
+    // A declined refund is a branch the workflow takes, not a crash that takes
+    // the whole segment — including the steps that record what happened — down.
+    await expect(
+      handler({ providerType: 'stripe', paymentReference: 'pi_1', currency: 'usd' }, {})
+    ).resolves.toBeDefined()
+  })
+})

package/dist/cjs/nodes/analytics/commerce-tracking.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The one way a generated workflow handler reports a commerce funnel step.
+ *
+ * ## Why a global and not an import
+ *
+ * A node handler ships as a SERIALIZED function body (`fn.toString()`) that is
+ * evaluated at runtime with no module scope — it cannot import anything. The
+ * analytics tracker publishes `window.tpTrackCommerce` when it boots, and that
+ * global is the only channel a handler can reach.
+ *
+ * ## Why every call is guarded twice
+ *
+ * The global is absent on any project that did not enable analytics, and absent
+ * on every server-side render. These handlers run inside add-to-cart and
+ * checkout, where an exception costs a sale — so a missing tracker has to be a
+ * silent no-op, never a `ReferenceError`. The `try` covers the second failure
+ * mode: a tracker that is present but throws (storage disabled, a browser
+ * extension replacing the global) must not take the cart down with it.
+ *
+ * ## ⛔ Why a calling node must NOT import `trackCommerceStep`
+ *
+ * TypeScript's CommonJS emit rewrites a cross-module call into
+ * `(0, commerce_tracking_1.trackCommerceStep)(...)`. That survives `.toString()`
+ * verbatim, and `commerce_tracking_1` does not exist in the generated workflow
+ * segment — so the handler throws `ReferenceError` the first time a shopper adds
+ * to the cart, in production only, because nothing about it is visible in the
+ * TypeScript source.
+ *
+ * A caller therefore declares the name AMBIENTLY (`declare function
+ * trackCommerceStep`), which emits nothing and leaves a bare identifier in the
+ * serialized body, and appends `COMMERCE_TRACKING_HELPER_SOURCE` so the runtime
+ * definition travels with it. `assertHandlerHasNoModuleRefs` fails the build if
+ * a module reference ever creeps back in.
+ */
+/** ES5 source of the helper, for concatenating after a serialized handler. */
+export declare const COMMERCE_TRACKING_HELPER_SOURCE: string;
+/**
+ * Fails the BUILD when a serialized handler still references a module namespace.
+ *
+ * Cheap insurance against a failure that is otherwise invisible: the TypeScript
+ * compiles, the tests that only read the source pass, and the handler throws in
+ * a shopper's browser. Called by every `generateHandler` that concatenates a
+ * helper.
+ */
+export declare function assertHandlerHasNoModuleRefs(source: string, nodeType: string): string;
+//# sourceMappingURL=commerce-tracking.d.ts.map

package/dist/cjs/nodes/analytics/commerce-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commerce-tracking.d.ts","sourceRoot":"","sources":["../../../../src/nodes/analytics/commerce-tracking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AA+BH,8EAA8E;AAC9E,eAAO,MAAM,+BAA+B,QAA+B,CAAA;AAQ3E;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWrF"}

package/dist/cjs/nodes/analytics/commerce-tracking.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * The one way a generated workflow handler reports a commerce funnel step.
+ *
+ * ## Why a global and not an import
+ *
+ * A node handler ships as a SERIALIZED function body (`fn.toString()`) that is
+ * evaluated at runtime with no module scope — it cannot import anything. The
+ * analytics tracker publishes `window.tpTrackCommerce` when it boots, and that
+ * global is the only channel a handler can reach.
+ *
+ * ## Why every call is guarded twice
+ *
+ * The global is absent on any project that did not enable analytics, and absent
+ * on every server-side render. These handlers run inside add-to-cart and
+ * checkout, where an exception costs a sale — so a missing tracker has to be a
+ * silent no-op, never a `ReferenceError`. The `try` covers the second failure
+ * mode: a tracker that is present but throws (storage disabled, a browser
+ * extension replacing the global) must not take the cart down with it.
+ *
+ * ## ⛔ Why a calling node must NOT import `trackCommerceStep`
+ *
+ * TypeScript's CommonJS emit rewrites a cross-module call into
+ * `(0, commerce_tracking_1.trackCommerceStep)(...)`. That survives `.toString()`
+ * verbatim, and `commerce_tracking_1` does not exist in the generated workflow
+ * segment — so the handler throws `ReferenceError` the first time a shopper adds
+ * to the cart, in production only, because nothing about it is visible in the
+ * TypeScript source.
+ *
+ * A caller therefore declares the name AMBIENTLY (`declare function
+ * trackCommerceStep`), which emits nothing and leaves a bare identifier in the
+ * serialized body, and appends `COMMERCE_TRACKING_HELPER_SOURCE` so the runtime
+ * definition travels with it. `assertHandlerHasNoModuleRefs` fails the build if
+ * a module reference ever creeps back in.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHandlerHasNoModuleRefs = exports.COMMERCE_TRACKING_HELPER_SOURCE = void 0;
+/**
+ * ⛔ EXACTLY ONE PARAMETER. Not a style choice.
+ *
+ * When this package is minified by a consumer, the handler's own entry function
+ * loses its conventional name, and `resolveHandlerEntryName` then identifies the
+ * entry by ARITY: it prefers a 2-param declaration, because every real handler
+ * entry is `(config, context)`. A 2-param helper concatenated after a 1-param
+ * entry therefore WINS, and the generated workflow calls the tracking helper
+ * where it meant to call add-to-cart.
+ *
+ * One object parameter keeps the helper out of that contest, and the resolver's
+ * positional fallback then correctly picks the entry, which is emitted first.
+ * `resolve-handler-entry-name.test.ts` checks every registered node type against
+ * exactly this, and is what caught it.
+ *
+ * Not exported either: exporting invites the cross-module call this file exists
+ * to prevent. It is here to be read by `.toString()` below, nothing else.
+ */
+function trackCommerceStep(step) {
+    try {
+        const tracker = globalThis.tpTrackCommerce;
+        if (typeof tracker === 'function') {
+            ;
+            tracker(step.name, step.detail);
+        }
+    }
+    catch (e) {
+        /* analytics must never break a cart or a checkout */
+    }
+}
+/** ES5 source of the helper, for concatenating after a serialized handler. */
+exports.COMMERCE_TRACKING_HELPER_SOURCE = trackCommerceStep.toString();
+/**
+ * Matches the two shapes TypeScript's CJS emit produces for a cross-module
+ * call — `(0, ns_1.fn)(…)` and a bare `ns_1.fn(…)`.
+ */
+const MODULE_REFERENCE = /\b[A-Za-z_$][\w$]*_\d+\s*\./;
+/**
+ * Fails the BUILD when a serialized handler still references a module namespace.
+ *
+ * Cheap insurance against a failure that is otherwise invisible: the TypeScript
+ * compiles, the tests that only read the source pass, and the handler throws in
+ * a shopper's browser. Called by every `generateHandler` that concatenates a
+ * helper.
+ */
+function assertHandlerHasNoModuleRefs(source, nodeType) {
+    const match = source.match(MODULE_REFERENCE);
+    if (match) {
+        throw new Error(`The "${nodeType}" handler references the module namespace "${match[0]}". ` +
+            'A serialized handler has no module scope, so this throws ReferenceError at ' +
+            'runtime. Declare the helper ambiently (declare function ...) and append its ' +
+            'source instead of importing it.');
+    }
+    return source;
+}
+exports.assertHandlerHasNoModuleRefs = assertHandlerHasNoModuleRefs;
+//# sourceMappingURL=commerce-tracking.js.map

package/dist/cjs/nodes/analytics/commerce-tracking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commerce-tracking.js","sourceRoot":"","sources":["../../../../src/nodes/analytics/commerce-tracking.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;;;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,iBAAiB,CAAC,IAAwD;IACjF,IAAI;QACF,MAAM,OAAO,GAAI,UAAsC,CAAC,eAAe,CAAA;QACvE,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;YACjC,CAAC;YAAC,OAA4D,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;SACvF;KACF;IAAC,OAAO,CAAC,EAAE;QACV,qDAAqD;KACtD;AACH,CAAC;AAED,8EAA8E;AACjE,QAAA,+BAA+B,GAAG,iBAAiB,CAAC,QAAQ,EAAE,CAAA;AAE3E;;;GAGG;AACH,MAAM,gBAAgB,GAAG,6BAA6B,CAAA;AAEtD;;;;;;;GAOG;AACH,SAAgB,4BAA4B,CAAC,MAAc,EAAE,QAAgB;IAC3E,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAA;IAC5C,IAAI,KAAK,EAAE;QACT,MAAM,IAAI,KAAK,CACb,QAAQ,QAAQ,8CAA8C,KAAK,CAAC,CAAC,CAAC,KAAK;YACzE,6EAA6E;YAC7E,8EAA8E;YAC9E,iCAAiC,CACpC,CAAA;KACF;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAXD,oEAWC"}

package/dist/cjs/nodes/cache/page-revalidate.d.ts

@@ -0,0 +1,3 @@
+import { NodeHandlerGenerator } from '../types';
+export declare const pageRevalidate: NodeHandlerGenerator;
+//# sourceMappingURL=page-revalidate.d.ts.map

package/dist/cjs/nodes/cache/page-revalidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-revalidate.d.ts","sourceRoot":"","sources":["../../../../src/nodes/cache/page-revalidate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAqIhE,eAAO,MAAM,cAAc,EAAE,oBAM5B,CAAA"}