@teleporthq/teleport-plugin-next-data-source 0.43.66 → 0.43.68

package/__tests__/localized-columns.test.ts

@@ -0,0 +1,217 @@
+import { parse } from '@babel/parser'
+import {
+  collectLocalizedColumns,
+  generateLocalizedColumnsHelper,
+  type LocalizedColumnMap,
+} from '../src/localized-columns'
+import { resolveContentLocalization, isLocalizedProject } from '../src/content-localization'
+import { buildProductTransformOptions, getTransformWrapperCode } from '../src/transformations'
+import { generateTeleportFetcher } from '../src/fetchers/teleport'
+
+/**
+ * A Spanish listing links to `es_slug` and sorts by `es_name`, so the SQL a
+ * fetch runs has to know about the per-language columns — otherwise the
+ * details page 404s on the very slug the card linked to. The helper is pinned
+ * here by RUNNING the emitted JavaScript, the same way the runtime does.
+ */
+
+const LOCALIZATION = { mainLocale: 'en', secondaryLocales: ['es', 'fr'] }
+
+const PRODUCT_COLUMNS = [
+  'id',
+  'name',
+  'slug',
+  'description',
+  'price',
+  'og_title',
+  'es_name',
+  'es_slug',
+  'es_description',
+  'fr_name',
+]
+
+interface Helper {
+  localizedEqualityClause: (
+    field: string,
+    operand: string,
+    value: unknown,
+    pushParam: (param: unknown) => string
+  ) => string | null
+  localizedSortFieldSql: (field: string, locale: unknown) => string | null
+}
+
+const loadHelper = (families: LocalizedColumnMap): Helper => {
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(
+    `${generateLocalizedColumnsHelper(
+      families
+    )}\nreturn { localizedEqualityClause, localizedSortFieldSql }`
+  )
+  return factory()
+}
+
+const bindParams = () => {
+  const params: unknown[] = []
+  const pushParam = (param: unknown) => {
+    params.push(param)
+    return '$' + params.length
+  }
+  return { params, pushParam }
+}
+
+describe('resolveContentLocalization', () => {
+  it('splits the project languages into the main locale and the copies', () => {
+    expect(
+      resolveContentLocalization({
+        internationalization: {
+          main: { name: 'English', locale: 'en' },
+          languages: { en: 'English', es: 'Spanish', fr: 'French' },
+        },
+      })
+    ).toEqual({ mainLocale: 'en', secondaryLocales: ['es', 'fr'] })
+  })
+
+  it('is absent for a single-language project', () => {
+    expect(resolveContentLocalization({})).toBeUndefined()
+    expect(isLocalizedProject({})).toBe(false)
+  })
+
+  it('reaches the fetcher through the shared transform options', () => {
+    const options = buildProductTransformOptions({
+      internationalization: {
+        main: { name: 'English', locale: 'en' },
+        languages: { en: 'English', es: 'Spanish' },
+      },
+    })
+    expect(options.localization).toEqual({ mainLocale: 'en', secondaryLocales: ['es'] })
+    expect(buildProductTransformOptions({}).localization).toBeUndefined()
+  })
+})
+
+describe('collectLocalizedColumns', () => {
+  it('pairs a column with the copies the schema actually holds', () => {
+    expect(collectLocalizedColumns(PRODUCT_COLUMNS, LOCALIZATION)).toEqual({
+      name: { es: 'es_name', fr: 'fr_name' },
+      slug: { es: 'es_slug' },
+      description: { es: 'es_description' },
+    })
+  })
+
+  it('never mistakes a prefix for a language', () => {
+    // `og_title` is Open Graph, and `og` is not a project language.
+    const families = collectLocalizedColumns(['title', 'og_title'], LOCALIZATION)
+    expect(families).toEqual({})
+  })
+
+  it('has nothing to say for a single-language project', () => {
+    expect(collectLocalizedColumns(PRODUCT_COLUMNS, undefined)).toEqual({})
+    expect(
+      collectLocalizedColumns(PRODUCT_COLUMNS, { mainLocale: 'en', secondaryLocales: [] })
+    ).toEqual({})
+  })
+
+  it('refuses a column it could not quote', () => {
+    const families = collectLocalizedColumns(['slug', 'es_slug', 'pt-BR_slug'], {
+      mainLocale: 'en',
+      secondaryLocales: ['es', 'pt-BR'],
+    })
+    expect(families).toEqual({ slug: { es: 'es_slug' } })
+  })
+})
+
+describe('generateLocalizedColumnsHelper', () => {
+  const families = collectLocalizedColumns(PRODUCT_COLUMNS, LOCALIZATION)
+  const helper = loadHelper(families)
+
+  it('emits plain source the fetcher template can embed', () => {
+    const source = generateLocalizedColumnsHelper(families)
+    expect(source).not.toContain('`')
+    expect(source).not.toContain('${')
+    expect(() => parse(source, { sourceType: 'script' })).not.toThrow()
+  })
+
+  it('matches equality on a translatable column in every language, binding once', () => {
+    const { params, pushParam } = bindParams()
+    const clause = helper.localizedEqualityClause('slug', '=', 'bolso-tote', pushParam)
+    expect(clause).toBe('("slug" = $1 OR "es_slug" = $1)')
+    expect(params).toEqual(['bolso-tote'])
+  })
+
+  it('answers an `in` set (already normalised to an array) the same way', () => {
+    const { params, pushParam } = bindParams()
+    const clause = helper.localizedEqualityClause('name', '=', ['A', 'B'], pushParam)
+    expect(clause).toBe(
+      '("name"::text = ANY($1::text[]) OR "es_name"::text = ANY($1::text[]) OR "fr_name"::text = ANY($1::text[]))'
+    )
+    expect(params).toEqual([['A', 'B']])
+  })
+
+  it('leaves every other column and operand to the ordinary branches', () => {
+    const { params, pushParam } = bindParams()
+    expect(helper.localizedEqualityClause('price', '=', '10', pushParam)).toBeNull()
+    expect(helper.localizedEqualityClause('slug', '!=', 'x', pushParam)).toBeNull()
+    expect(helper.localizedEqualityClause('slug', '=', null, pushParam)).toBeNull()
+    // An empty set means "no filter", as it does in the ordinary array branch.
+    expect(helper.localizedEqualityClause('slug', '=', [], pushParam)).toBeNull()
+    expect(params).toEqual([])
+  })
+
+  it("orders by the request's language, falling back to the base column", () => {
+    expect(helper.localizedSortFieldSql('name', 'es')).toBe(
+      `COALESCE(NULLIF("es_name", ''), "name")`
+    )
+    // The main language and a language without a copy order by the column itself.
+    expect(helper.localizedSortFieldSql('name', 'en')).toBeNull()
+    expect(helper.localizedSortFieldSql('slug', 'fr')).toBeNull()
+    expect(helper.localizedSortFieldSql('price', 'es')).toBeNull()
+    expect(helper.localizedSortFieldSql('name', null)).toBeNull()
+  })
+
+  it('is inert without families', () => {
+    const inert = loadHelper({})
+    const { pushParam } = bindParams()
+    expect(inert.localizedEqualityClause('slug', '=', 'x', pushParam)).toBeNull()
+    expect(inert.localizedSortFieldSql('name', 'es')).toBeNull()
+  })
+})
+
+describe('teleport fetcher — localized columns', () => {
+  const config = {
+    selectedTables: {
+      teleport_products: { columns: PRODUCT_COLUMNS.map((name) => ({ name })) },
+    },
+  }
+
+  it('bakes the column map from the table schema and the project languages', () => {
+    const route = generateTeleportFetcher(config, 'teleport_products', {
+      localization: LOCALIZATION,
+    })
+    expect(route).toContain(
+      'var LOCALIZED_COLUMNS = {"name":{"es":"es_name","fr":"fr_name"},"slug":{"es":"es_slug"},"description":{"es":"es_description"}}'
+    )
+    expect(route).toContain('const localizedClause = localizedEqualityClause(field, operand, value')
+    expect(route).toContain(
+      "const requestLocale = typeof req.query.locale === 'string' ? req.query.locale : null"
+    )
+    expect(route).toContain(
+      'localizedSortFieldSql(sort.field, requestLocale) || sortFieldSql(sort.field)'
+    )
+    expect(route).toContain('localizedSortFieldSql(sortBy, requestLocale) || sortBy')
+  })
+
+  it('bakes an empty map for a single-language project', () => {
+    const route = generateTeleportFetcher(config, 'teleport_products')
+    expect(route).toContain('var LOCALIZED_COLUMNS = {}')
+  })
+
+  it('resolves the row transform against the request locale and the baked main locale', () => {
+    const wrapper = getTransformWrapperCode('teleport_products', { localization: LOCALIZATION })
+    expect(wrapper).toContain(
+      "var currentLanguage = reqQuery && typeof reqQuery.locale === 'string' && reqQuery.locale ? reqQuery.locale : null"
+    )
+    expect(wrapper).toContain('mainLanguage: "en"')
+    expect(wrapper).not.toContain('reqQuery.lang')
+
+    expect(getTransformWrapperCode('teleport_products')).toContain('mainLanguage: null')
+  })
+})

package/__tests__/numbered-pagination.test.ts

@@ -89,6 +89,21 @@ describe('pagination plugin — numbered mode', () => {
     expect(code).toContain('setDs_0_maxPages(data.count === 0 ? 0 : Math.ceil(data.count / 20))')
   })
 
+  it('drops a count response a newer count request has overtaken', async () => {
+    // Two filter changes in quick succession start two counts; the older,
+    // slower one landing last must not paint a strip for rows no longer shown.
+    const code = await runPlugin({ paginationMode: 'numbered' }, NUMBERED_CONTROLS)
+    const flat = collapse(code)
+
+    expect(flat).toContain('const ds_0_countSeq = useRef(0)')
+    expect(flat).toContain('const __tqCountSeq = ++ds_0_countSeq.current')
+    expect(flat).toContain('if (__tqCountSeq !== ds_0_countSeq.current) return;')
+    // The guard sits before the setter, inside the response handler.
+    expect(flat.indexOf('if (__tqCountSeq !== ds_0_countSeq.current) return;')).toBeLessThan(
+      flat.indexOf('setDs_0_maxPages(data.count === 0')
+    )
+  })
+
   it('removes a numbered strip left over from a mode switch', async () => {
     // The builder never deletes controls on a mode switch (that would discard
     // the author's styling), so a Previous/Next list can still carry them.

package/__tests__/product-filter-fields.ts

@@ -0,0 +1,230 @@
+import { parse } from '@babel/parser'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import {
+  PRODUCT_ON_SALE_FILTER_FIELD,
+  PRODUCT_RATING_FILTER_FIELD,
+  PRODUCT_VARIANT_AXIS_FILTER_PREFIX,
+  PRODUCT_VARIANT_AXIS_KEY_PATTERN,
+  buildProductOnSaleSql,
+  buildProductRatingBucketSql,
+  buildProductVariantAxisExistsSql,
+  generateProductFilterClauseHelper,
+} from '../src/product-filter-fields'
+import { buildProductEffectivePriceSql } from '../src/product-price-sort'
+import { generateTeleportFetcher } from '../src/fetchers/teleport'
+import { generatePostgreSQLFetcher } from '../src/fetchers/postgresql'
+import { generateMySQLFetcher } from '../src/fetchers/mysql'
+import { generateDataSourceFetcher } from '../src/data-source-fetchers'
+import { generateFilterTreeHelpersCode } from '../src/utils'
+
+/**
+ * The storefront's product filters on things that are not a column: the price
+ * paid today, the star bucket, the on-sale flag and a variant axis. They are
+ * answered in SQL — the list is paginated — so the emitted helper is pinned
+ * here the same way the discount-aware sort is.
+ */
+
+const PG_CONFIG = { connectionString: 'postgres://user:pw@host:5432/db' }
+
+/** Runs the emitted helper as real JS and returns the clause + bound params. */
+function runHelper(
+  tableName: string,
+  field: string,
+  operand: string,
+  value: unknown
+): { clause: string | null; params: unknown[] } {
+  const params: unknown[] = []
+  let index = 1
+  const pushParam = (param: unknown) => {
+    params.push(param)
+    return '$' + index++
+  }
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(
+    `${generateProductFilterClauseHelper(tableName)}\nreturn productFilterClause`
+  )
+  const clause = factory()(field, operand, value, pushParam)
+  return { clause, params }
+}
+
+/** Runs the emitted `normalizeInOperand` as real JS. */
+function runNormalize(operand: string, value: unknown): unknown {
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(`${generateFilterTreeHelpersCode()}\nreturn normalizeInOperand`)
+  return factory()(operand, value)
+}
+
+describe('generateProductFilterClauseHelper', () => {
+  it('is the identity for every table but the products table', () => {
+    const helper = generateProductFilterClauseHelper('teleport_orders')
+    expect(helper).toContain('return null')
+    expect(helper).not.toContain('jsonb_array_elements')
+    expect(runHelper('teleport_orders', 'rating', '=', '4').clause).toBeNull()
+  })
+
+  it('emits the SQL as double-quoted literals, carrying no template syntax', () => {
+    const helper = generateProductFilterClauseHelper('teleport_products')
+    expect(helper).not.toContain('`')
+    expect(helper).not.toContain('${')
+    expect(() => parse(helper, { sourceType: 'script' })).not.toThrow()
+  })
+
+  it('leaves a plain column to the ordinary branches', () => {
+    expect(runHelper('teleport_products', 'brand', '=', 'Acme').clause).toBeNull()
+    expect(runHelper('teleport_products', 'brand', '=', ['Acme', 'Globex']).clause).toBeNull()
+  })
+
+  it('filters price on what customers pay today, like the price sort', () => {
+    const { clause, params } = runHelper('teleport_products', 'price', '<=', '50')
+    expect(clause).toBe(`(${buildProductEffectivePriceSql()}) <= $1`)
+    expect(params).toEqual(['50'])
+  })
+
+  it('answers a star bucket over approved reviews only', () => {
+    const sql = buildProductRatingBucketSql()
+    expect(sql).toContain("r.status = 'approved'")
+    expect(sql).toContain('ROUND(AVG(r.rating))')
+    expect(sql).toContain('r.product_id = teleport_products.id')
+
+    const { clause, params } = runHelper('teleport_products', PRODUCT_RATING_FILTER_FIELD, '=', [
+      '4',
+      '5',
+    ])
+    expect(clause).toBe(`${sql}::text = ANY($1::text[])`)
+    expect(params).toEqual([['4', '5']])
+  })
+
+  it('reads the on-sale flag off the effective price', () => {
+    const sql = buildProductOnSaleSql()
+    expect(sql).toContain(`< "price"::numeric THEN 'true' ELSE 'false'`)
+    const { clause, params } = runHelper(
+      'teleport_products',
+      PRODUCT_ON_SALE_FILTER_FIELD,
+      '=',
+      'true'
+    )
+    expect(clause).toBe(`${sql} = $1`)
+    expect(params).toEqual(['true'])
+  })
+
+  it('binds the axis key and the values, never interpolating them', () => {
+    const { clause, params } = runHelper(
+      'teleport_products',
+      `${PRODUCT_VARIANT_AXIS_FILTER_PREFIX}size`,
+      '=',
+      ['xl', 'l']
+    )
+    expect(clause).toBe(buildProductVariantAxisExistsSql('$1', '$2'))
+    expect(clause).toContain("ax->>'key' = $1")
+    expect(clause).toContain("v->>'value' = ANY($2::text[])")
+    expect(params).toEqual(['size', ['xl', 'l']])
+  })
+
+  it('casts the JSON column only when it already looks like an array', () => {
+    const sql = buildProductVariantAxisExistsSql('$1', '$2')
+    expect(sql).toContain(`btrim("variant_options") NOT LIKE '[%'`)
+    expect(sql).toContain(`jsonb_typeof(ax->'values') = 'array'`)
+  })
+
+  it('refuses an axis key the editor could never have written', () => {
+    expect(new RegExp(PRODUCT_VARIANT_AXIS_KEY_PATTERN).test('size')).toBe(true)
+    expect(new RegExp(PRODUCT_VARIANT_AXIS_KEY_PATTERN).test('shoe-size_2')).toBe(true)
+    expect(new RegExp(PRODUCT_VARIANT_AXIS_KEY_PATTERN).test(`x' OR 1=1 --`)).toBe(false)
+    const { clause, params } = runHelper(
+      'teleport_products',
+      `${PRODUCT_VARIANT_AXIS_FILTER_PREFIX}x' OR 1=1 --`,
+      '=',
+      ['a']
+    )
+    expect(clause).toBe('FALSE')
+    expect(params).toEqual([])
+  })
+
+  it('never lets a virtual field fall into a column branch', () => {
+    // A `>` on the on-sale flag has no meaning; the fallthrough would emit
+    // `on_sale > $1` and fail the whole query.
+    expect(runHelper('teleport_products', PRODUCT_ON_SALE_FILTER_FIELD, '>', 'x').clause).toBe(
+      'FALSE'
+    )
+    expect(
+      runHelper('teleport_products', `${PRODUCT_VARIANT_AXIS_FILTER_PREFIX}size`, '>', ['xl'])
+        .clause
+    ).toBe('FALSE')
+  })
+})
+
+describe('normalizeInOperand', () => {
+  it('turns "in" into "=" over an array, so every fetcher answers IN (...)', () => {
+    expect(runNormalize('in', 'a, b,,c')).toEqual({ operand: '=', value: ['a', 'b', 'c'] })
+    expect(runNormalize('in', ['a', 'b,c', 4])).toEqual({ operand: '=', value: ['a', 'b', 'c', 4] })
+  })
+
+  it('reads an empty set as "no filter"', () => {
+    expect(runNormalize('in', '')).toBeNull()
+    expect(runNormalize('in', [])).toBeNull()
+    expect(runNormalize('in', ' , ')).toBeNull()
+  })
+
+  it('passes every other operand through untouched', () => {
+    expect(runNormalize('=', 'a,b')).toEqual({ operand: '=', value: 'a,b' })
+    expect(runNormalize('array_overlap', 'a,b')).toEqual({ operand: 'array_overlap', value: 'a,b' })
+  })
+})
+
+describe('the generated routes', () => {
+  it('answer the virtual fields before any raw-field branch, in the fetcher a store uses', () => {
+    // Through the type dispatch, not one fetcher's export: `teleport_products`
+    // is a Teleport-hosted table, and the discount sort once shipped into the
+    // wrong fetcher with every test green.
+    const route = generateDataSourceFetcher({ type: 'teleport', config: {} }, 'teleport_products')
+    expect(route).toContain('function productFilterClause(field, operand, value, pushParam)')
+    const conditionAt = route.indexOf('const buildCondition = (condition) =>')
+    const hookAt = route.indexOf('const productClause = productFilterClause(', conditionAt)
+    const arrayBranchAt = route.indexOf('if (Array.isArray(value))', conditionAt)
+    expect(conditionAt).toBeGreaterThan(-1)
+    expect(hookAt).toBeGreaterThan(conditionAt)
+    expect(arrayBranchAt).toBeGreaterThan(hookAt)
+    expect(route).toContain('normalizeInOperand(condition.operand, condition.destination)')
+    expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+
+  it('embed the helper in the Postgres route too, and parse', () => {
+    const route = generatePostgreSQLFetcher(PG_CONFIG, 'teleport_products')
+    expect(route).toContain('const productClause = productFilterClause(')
+    expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+
+  it('give every other SQL fetcher the "in" normalisation, and nothing else', () => {
+    const route = generateMySQLFetcher({ host: 'h' }, 'orders')
+    expect(route).toContain('normalizeInOperand(condition.operand, condition.destination)')
+    expect(route).not.toContain('productFilterClause')
+    expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+
+  it('keep a non-products Teleport table on the ordinary branches', () => {
+    const route = generateTeleportFetcher({}, 'teleport_orders')
+    expect(route).toContain('function productFilterClause() {')
+    expect(route).not.toContain('jsonb_array_elements(CASE')
+    expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+})
+
+describe('the SQL mirrored into database-provider-worker', () => {
+  // `database-provider-worker/src/lib/__tests__/product-filter-sql.fixture.json`
+  // is a copy of this file. Both repos pin their builders to it, so the canvas
+  // and the generated store can never disagree about what a filter means.
+  const fixture = JSON.parse(
+    readFileSync(join(__dirname, 'product-filter-sql.fixture.json'), 'utf8')
+  ) as Record<string, string>
+
+  it('matches the shared fixture byte for byte', () => {
+    expect(buildProductEffectivePriceSql()).toBe(fixture.effectivePrice)
+    expect(buildProductRatingBucketSql()).toBe(fixture.ratingBucket)
+    expect(buildProductOnSaleSql()).toBe(fixture.onSale)
+    expect(buildProductVariantAxisExistsSql('__KEY__', '__VALUES__')).toBe(
+      fixture.variantAxisExists
+    )
+    expect(PRODUCT_VARIANT_AXIS_KEY_PATTERN).toBe(fixture.axisKeyPattern)
+  })
+})

package/__tests__/product-filter-sql.fixture.json

@@ -0,0 +1,7 @@
+{
+  "effectivePrice": "COALESCE((\n    SELECT ROUND(GREATEST(0,\n      CASE\n        WHEN entry.kind = 'percentage'\n          THEN \"price\"::numeric * (1 - LEAST(entry.amount, 100) / 100)\n        ELSE \"price\"::numeric - entry.amount\n      END\n    ), 2)\n    FROM (\n      SELECT\n        d.value->>'type' AS kind,\n        CASE\n          WHEN d.value->>'value' ~ '^[0-9]+(\\.[0-9]+)?$' THEN (d.value->>'value')::numeric\n          ELSE 0\n        END AS amount,\n        d.value->>'startsAt' AS starts_at,\n        d.value->>'endsAt' AS ends_at,\n        d.ord AS ord\n      FROM jsonb_array_elements(CASE\n        WHEN \"discounts\" IS NULL OR btrim(\"discounts\") NOT LIKE '[%' THEN '[]'::jsonb\n        ELSE \"discounts\"::jsonb\n      END) WITH ORDINALITY AS d(value, ord)\n    ) AS entry\n    WHERE entry.amount > 0\n      AND entry.kind IN ('percentage', 'fixed')\n      AND (entry.starts_at IS NULL OR entry.starts_at <= to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'))\n      AND (entry.ends_at IS NULL OR entry.ends_at > to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'))\n    ORDER BY entry.ord\n    LIMIT 1\n  ), \"price\"::numeric)",
+  "ratingBucket": "(SELECT ROUND(AVG(r.rating)) FROM teleport_product_reviews r WHERE r.product_id = teleport_products.id AND r.status = 'approved' AND r.rating IS NOT NULL)",
+  "onSale": "(CASE WHEN COALESCE((\n    SELECT ROUND(GREATEST(0,\n      CASE\n        WHEN entry.kind = 'percentage'\n          THEN \"price\"::numeric * (1 - LEAST(entry.amount, 100) / 100)\n        ELSE \"price\"::numeric - entry.amount\n      END\n    ), 2)\n    FROM (\n      SELECT\n        d.value->>'type' AS kind,\n        CASE\n          WHEN d.value->>'value' ~ '^[0-9]+(\\.[0-9]+)?$' THEN (d.value->>'value')::numeric\n          ELSE 0\n        END AS amount,\n        d.value->>'startsAt' AS starts_at,\n        d.value->>'endsAt' AS ends_at,\n        d.ord AS ord\n      FROM jsonb_array_elements(CASE\n        WHEN \"discounts\" IS NULL OR btrim(\"discounts\") NOT LIKE '[%' THEN '[]'::jsonb\n        ELSE \"discounts\"::jsonb\n      END) WITH ORDINALITY AS d(value, ord)\n    ) AS entry\n    WHERE entry.amount > 0\n      AND entry.kind IN ('percentage', 'fixed')\n      AND (entry.starts_at IS NULL OR entry.starts_at <= to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'))\n      AND (entry.ends_at IS NULL OR entry.ends_at > to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'))\n    ORDER BY entry.ord\n    LIMIT 1\n  ), \"price\"::numeric) < \"price\"::numeric THEN 'true' ELSE 'false' END)",
+  "variantAxisExists": "EXISTS (SELECT 1 FROM jsonb_array_elements(CASE\n        WHEN \"variant_options\" IS NULL OR btrim(\"variant_options\") NOT LIKE '[%' THEN '[]'::jsonb\n        ELSE \"variant_options\"::jsonb\n      END) AS ax, jsonb_array_elements(CASE WHEN jsonb_typeof(ax->'values') = 'array' THEN ax->'values' ELSE '[]'::jsonb END) AS v WHERE ax->>'key' = __KEY__ AND v->>'value' = ANY(__VALUES__::text[]))",
+  "axisKeyPattern": "^[a-z0-9][a-z0-9_-]{0,63}$"
+}