@elytracms/studio 0.0.101 → 0.0.102

package/convex/asset-alt-migration.test.ts

@@ -1,127 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { convexTest } from 'convex-test'
-import { makeFunctionReference } from 'convex/server'
-import { measureMaxDepth } from '@elytracms/core/cms-core'
-import { InMemoryAssetRepository, assetAlt, liftLegacyAssetAlts } from '@elytracms/core/persistence'
-import type { AssetRecord } from '@elytracms/core/persistence'
-import schema from './schema'
-
-// convex-test fires a `runAfter(0)` on a REAL timer; fake timers keep the scheduled
-// revalidations queued (rows written, the `webhooks:deliver` fetch never fired).
-beforeEach(() => {
-  vi.useFakeTimers()
-})
-afterEach(() => {
-  vi.useRealTimers()
-})
-
-/**
- * EC-587 — the one-shot migration of the legacy `alt` column into `meta.alt`, its one
- * home: the REAL internal mutation (`assets:liftLegacyAlt`, the line the operator runs
- * with `npx convex run`) on convex-test's backend, and the in-memory runner
- * (`liftLegacyAssetAlts`) held to the same expectations over the same rows.
- */
-
-const modules = {
-  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
-  './_generated/api.ts': async () => ({}),
-}
-
-const liftLegacyAlt = makeFunctionReference<'mutation'>('assets:liftLegacyAlt')
-
-const STAMP = '2026-10-26T00:00:00.000Z'
-
-/** The four shapes a stored asset row can hold its alt in. */
-const ROWS = [
-  { assetId: 'column_only', alt: 'Harbour' },
-  { assetId: 'both', alt: 'stale column', meta: { alt: 'Meta wins', credit: 'Ada' } },
-  { assetId: 'meta_only', meta: { alt: 'Already home' } },
-  { assetId: 'none', meta: { credit: 'Jo' } },
-] as const
-
-function row(input: (typeof ROWS)[number]) {
-  return {
-    filename: `${input.assetId}.jpg`,
-    contentType: 'image/jpeg',
-    byteSize: 1,
-    storageKey: `k_${input.assetId}`,
-    createdAt: STAMP,
-    updatedAt: STAMP,
-    ...input,
-  }
-}
-
-/** What every reader sees BEFORE the lift — the migration must not change it. */
-const READ_BEFORE = { column_only: 'Harbour', both: 'Meta wins', meta_only: 'Already home', none: null }
-
-const EXPECTED_META = {
-  column_only: { alt: 'Harbour' },
-  both: { alt: 'Meta wins', credit: 'Ada' },
-  meta_only: { alt: 'Already home' },
-  none: { credit: 'Jo' },
-}
-
-async function seededBackend() {
-  const t = convexTest(schema, modules)
-  await t.run(async (ctx) => {
-    for (const input of ROWS) await ctx.db.insert('assets', row(input) as never)
-  })
-  return t
-}
-
-async function storedRows(t: Awaited<ReturnType<typeof seededBackend>>) {
-  return t.run(async (ctx) => {
-    const rows = await ctx.db.query('assets').collect()
-    return Object.fromEntries(rows.map((r) => [r.assetId, { alt: r.alt, meta: r.meta }]))
-  })
-}
-
-describe('EC-587 — assets:liftLegacyAlt moves the legacy column home, once', () => {
-  it('lifts the column into meta.alt (meta.alt wins when both), unsets it, and keeps every alt reading', async () => {
-    const t = await seededBackend()
-    const before = await storedRows(t)
-    expect(Object.fromEntries(Object.entries(before).map(([id, r]) => [id, assetAlt(r, null)]))).toEqual(READ_BEFORE)
-
-    const report = (await t.mutation(liftLegacyAlt, {})) as { scanned: number; lifted: string[] }
-    expect(report.scanned).toBe(4)
-    expect([...report.lifted].sort()).toEqual(['both', 'column_only'])
-
-    const after = await storedRows(t)
-    for (const [id, stored] of Object.entries(after)) {
-      expect(stored.alt, `${id}: the column is gone`).toBeUndefined()
-      expect(stored.meta, `${id}: meta`).toEqual(EXPECTED_META[id as keyof typeof EXPECTED_META])
-      // convex-test enforces no nesting depth — the stored shape asserts it itself.
-      expect(measureMaxDepth(stored.meta).depth).toBeLessThanOrEqual(16)
-    }
-    // The lift changes no reading: every alt is what it was.
-    expect(Object.fromEntries(Object.entries(after).map(([id, r]) => [id, assetAlt(r, null)]))).toEqual(READ_BEFORE)
-  })
-
-  it('is idempotent: a second run lifts nothing and writes nothing', async () => {
-    const t = await seededBackend()
-    await t.mutation(liftLegacyAlt, {})
-    const once = await storedRows(t)
-    const scheduledAfterFirst = await t.run(async (ctx) => (await ctx.db.system.query('_scheduled_functions').collect()).length)
-    const again = (await t.mutation(liftLegacyAlt, {})) as { scanned: number; lifted: string[] }
-    expect(again).toEqual({ scanned: 4, lifted: [] })
-    expect(await storedRows(t)).toEqual(once)
-    const scheduledAfterSecond = await t.run(async (ctx) => (await ctx.db.system.query('_scheduled_functions').collect()).length)
-    expect(scheduledAfterSecond).toBe(scheduledAfterFirst)
-  })
-
-  it('the in-memory runner does the same to the same rows (the playground / headless equivalent)', async () => {
-    const records: AssetRecord[] = ROWS.map((input) => {
-      const { assetId, ...rest } = row(input)
-      return { ...rest, id: assetId, projectId: 'p' } as AssetRecord
-    })
-    const repo = new InMemoryAssetRepository({ seed: records })
-    const report = await liftLegacyAssetAlts(repo, 'p')
-    expect(report.scanned).toBe(4)
-    expect([...report.lifted].sort()).toEqual(['both', 'column_only'])
-    const after = await repo.listAssets('p')
-    expect(Object.fromEntries(after.map((r) => [r.id, { alt: r.alt, meta: r.meta }]))).toEqual(
-      Object.fromEntries(Object.entries(EXPECTED_META).map(([id, meta]) => [id, { alt: undefined, meta }])),
-    )
-    expect((await liftLegacyAssetAlts(repo, 'p')).lifted).toEqual([])
-  })
-})

package/convex/redirect-migration.test.ts

@@ -1,205 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { convexTest } from 'convex-test'
-import { makeFunctionReference } from 'convex/server'
-import schema from './schema'
-
-// convex-test fires `runAfter(0)` on a REAL timer; fake timers keep any scheduled
-// revalidation queued (rows written, the `webhooks:deliver` fetch never fired).
-beforeEach(() => {
-  vi.useFakeTimers()
-})
-afterEach(() => {
-  vi.useRealTimers()
-})
-
-/**
- * EC-616 — the redirect move from the `redirects` table into `records` (kind `redirect`)
- * is a STORED-DATA move (both production consumers hold real redirects), done the EC-587
- * way: writes to the new home, a marked tolerant read of the old one, an idempotent
- * per-deployment migration. These run the REAL functions on convex-test over legacy rows
- * inserted as a pre-EC-616 deployment holds them, and pin "no gap": a deployment with the
- * new functions pushed and the migration NOT yet run serves exactly what it served before.
- */
-
-const modules = {
-  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
-  './_generated/api.ts': async () => ({}),
-}
-
-const listRedirects = makeFunctionReference<'query'>('redirects:list')
-const getRedirect = makeFunctionReference<'query'>('redirects:get')
-const saveRedirect = makeFunctionReference<'mutation'>('redirects:save')
-const removeRedirect = makeFunctionReference<'mutation'>('redirects:remove')
-const migrateLegacy = makeFunctionReference<'mutation'>('redirects:migrateLegacy')
-const snapshot = makeFunctionReference<'query'>('delivery:snapshot')
-
-const STAMP = '2026-08-01T00:00:00.000Z'
-const LATER = '2026-10-26T00:00:00.000Z'
-
-/** Rows as a pre-EC-616 deployment stores them in the legacy `redirects` table. */
-const LEGACY = [
-  { redirectId: 'r_spring', from: '/spring', to: '/offers', permanent: true, enabled: true },
-  { redirectId: 'r_paused', from: '/paused', to: '/x', permanent: false, enabled: false, meta: { note: 'later' } },
-  { redirectId: 'r_blog', from: '/blog-old', to: '/blog', permanent: true, enabled: true },
-  // Stored before EC-577 refused it: a meta key naming a column. The current schema
-  // refuses this row as a create, so the migration must REPORT it, never drop it.
-  { redirectId: 'r_shadow', from: '/shadow', to: '/real', permanent: true, enabled: true, meta: { to: '/fake' } },
-] as const
-
-async function legacyDeployment(configuredRevalidation = false) {
-  const env = (globalThis as { process: { env: Record<string, string | undefined> } }).process.env
-  if (configuredRevalidation) {
-    env['CANVAS_REVALIDATE_ENDPOINT'] = 'https://host.invalid/api/revalidate'
-    env['CANVAS_REVALIDATE_SECRET'] = 'ec616-secret'
-  }
-  const t = convexTest(schema, modules)
-  await t.run(async (ctx) => {
-    await ctx.db.insert('members', { userId: 'editor', role: 'editor', createdAt: STAMP, updatedAt: STAMP })
-    for (const row of LEGACY) await ctx.db.insert('redirects', { ...row, createdAt: STAMP, updatedAt: STAMP })
-  })
-  const asEditor = t.withIdentity({ subject: 'editor', issuer: 'https://convex.test' })
-  return { t, asEditor }
-}
-
-afterEach(() => {
-  const env = (globalThis as { process: { env: Record<string, string | undefined> } }).process.env
-  delete env['CANVAS_REVALIDATE_ENDPOINT']
-  delete env['CANVAS_REVALIDATE_SECRET']
-})
-
-/** What the pre-EC-616 functions returned for the legacy rows: each row flat, ordered by `from`. */
-const SERVED_BEFORE = [...LEGACY]
-  .sort((a, b) => (a.from < b.from ? -1 : 1))
-  .map((row) => ({ ...row, createdAt: STAMP, updatedAt: STAMP }))
-
-/** What the pre-EC-616 snapshot served: the enabled rows as routing records. */
-const LIVE_BEFORE = LEGACY.filter((row) => row.enabled).map((row) => ({
-  id: row.redirectId,
-  from: row.from,
-  to: row.to,
-  permanent: row.permanent,
-}))
-
-const byId = (a: { id: string }, b: { id: string }) => (a.id < b.id ? -1 : 1)
-
-async function counts(t: Awaited<ReturnType<typeof legacyDeployment>>['t']) {
-  return t.run(async (ctx) => ({
-    legacy: (await ctx.db.query('redirects').collect()).length,
-    records: (await ctx.db.query('records').collect()).filter((row) => row.kind === 'redirect').length,
-  }))
-}
-
-describe('the redirect move: no gap before the migration runs (EC-616)', () => {
-  it('list, get and the delivery snapshot serve the legacy rows exactly as before', async () => {
-    const { asEditor } = await legacyDeployment()
-    expect(await asEditor.query(listRedirects, {})).toEqual(SERVED_BEFORE)
-    expect(await asEditor.query(getRedirect, { redirectId: 'r_paused' })).toEqual(
-      SERVED_BEFORE.find((row) => row.redirectId === 'r_paused'),
-    )
-    const served = (await asEditor.query(snapshot, { projectId: 'demo' })) as { redirects: { id: string }[] }
-    expect([...served.redirects].sort(byId)).toEqual([...LIVE_BEFORE].sort(byId))
-  })
-
-  it('a save of a legacy-only redirect lifts it: an edit, not a create; the legacy row goes', async () => {
-    const { t, asEditor } = await legacyDeployment()
-    // An edit that leaves `enabled`/`permanent` absent keeps the STORED (legacy) values.
-    const saved = await asEditor.mutation(saveRedirect, {
-      redirectId: 'r_paused',
-      to: '/y',
-      createdAt: LATER,
-      updatedAt: LATER,
-    })
-    expect(saved).toEqual({
-      redirectId: 'r_paused',
-      from: '/paused',
-      to: '/y',
-      permanent: false,
-      enabled: false,
-      meta: { note: 'later' },
-      createdAt: STAMP,
-      updatedAt: LATER,
-    })
-    expect(await counts(t)).toEqual({ legacy: 3, records: 1 })
-    expect((await asEditor.query(listRedirects, {})) as unknown[]).toHaveLength(4)
-  })
-
-  it('a remove of a legacy-only redirect deletes it (it never resurfaces)', async () => {
-    const { t, asEditor } = await legacyDeployment()
-    await asEditor.mutation(removeRedirect, { redirectId: 'r_blog' })
-    expect(await asEditor.query(getRedirect, { redirectId: 'r_blog' })).toBeNull()
-    expect(await counts(t)).toEqual({ legacy: 3, records: 0 })
-  })
-})
-
-describe('redirects:migrateLegacy (EC-616)', () => {
-  it('moves every valid legacy row, reports the refused one, and serves the same set after', async () => {
-    const { t, asEditor } = await legacyDeployment()
-    const first = await t.mutation(migrateLegacy, {})
-    expect(first).toEqual({
-      scanned: 4,
-      moved: 3,
-      shadowed: 0,
-      refused: [{ redirectId: 'r_shadow', message: expect.stringMatching(/meta may not use a column name/) }],
-      movedIds: ['r_blog', 'r_paused', 'r_spring'],
-    })
-    expect(await counts(t)).toEqual({ legacy: 1, records: 3 })
-    // The served set is unchanged by the move — the refused row still serves (tolerant read).
-    expect(await asEditor.query(listRedirects, {})).toEqual(SERVED_BEFORE)
-    const served = (await asEditor.query(snapshot, { projectId: 'demo' })) as { redirects: { id: string }[] }
-    expect([...served.redirects].sort(byId)).toEqual([...LIVE_BEFORE].sort(byId))
-  })
-
-  it('is idempotent: a second run moves nothing', async () => {
-    const { t } = await legacyDeployment()
-    await t.mutation(migrateLegacy, {})
-    expect(await t.mutation(migrateLegacy, {})).toMatchObject({ scanned: 1, moved: 0, shadowed: 0 })
-    expect(await counts(t)).toEqual({ legacy: 1, records: 3 })
-  })
-
-  it('drops a legacy row a record already shadows (a save lifted it meanwhile)', async () => {
-    const { t, asEditor } = await legacyDeployment()
-    // Simulate the race the transaction cannot have: a record and its legacy row both present.
-    await t.run(async (ctx) => {
-      await ctx.db.insert('redirects', {
-        redirectId: 'r_twice',
-        from: '/twice',
-        to: '/a',
-        permanent: true,
-        enabled: true,
-        createdAt: STAMP,
-        updatedAt: STAMP,
-      })
-    })
-    await asEditor.mutation(saveRedirect, { redirectId: 'r_twice', from: '/twice', to: '/b', createdAt: LATER, updatedAt: LATER })
-    await t.run(async (ctx) => {
-      await ctx.db.insert('redirects', {
-        redirectId: 'r_twice',
-        from: '/twice',
-        to: '/a',
-        permanent: true,
-        enabled: true,
-        createdAt: STAMP,
-        updatedAt: STAMP,
-      })
-    })
-    // The record wins every read while both exist…
-    expect(await asEditor.query(getRedirect, { redirectId: 'r_twice' })).toMatchObject({ to: '/b' })
-    // …and the migration drops the shadowed legacy row instead of overwriting the record.
-    expect(await t.mutation(migrateLegacy, {})).toMatchObject({ shadowed: 1 })
-    expect(await asEditor.query(getRedirect, { redirectId: 'r_twice' })).toMatchObject({ to: '/b' })
-  })
-
-  it('schedules no revalidation: the served set is identical before and after', async () => {
-    const { t } = await legacyDeployment(true)
-    await t.mutation(migrateLegacy, {})
-    const scheduled = await t.run(async (ctx) => ctx.db.system.query('_scheduled_functions').collect())
-    expect(scheduled).toEqual([])
-  })
-
-  it('control: a redirect SAVE on the same configured deployment does schedule one', async () => {
-    const { t, asEditor } = await legacyDeployment(true)
-    await asEditor.mutation(saveRedirect, { redirectId: 'r_new', from: '/n', to: '/m', createdAt: LATER, updatedAt: LATER })
-    const scheduled = await t.run(async (ctx) => ctx.db.system.query('_scheduled_functions').collect())
-    expect(scheduled.map((row) => (row.args as [{ event: unknown }])[0].event)).toEqual([{ kind: 'redirects' }])
-  })
-})

package/convex/version-kind-stamping.test.ts

@@ -1,118 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { convexTest } from 'convex-test'
-import { makeFunctionReference } from 'convex/server'
-import { foldDocument } from '@elytracms/core/cms-core'
-import type { CmsDocument } from '@elytracms/core/cms-core'
-import { VERSION_KIND_STAMP_BOUND, isPinnableVersion, scanStoredShapes } from '@elytracms/core/persistence'
-import schema from './schema'
-
-beforeEach(() => {
-  vi.useFakeTimers()
-})
-afterEach(() => {
-  vi.useRealTimers()
-})
-
-/**
- * EC-707 — the EC-585 kind stamping, the REAL internal mutation (`cms:stampVersionKinds`,
- * the line an admin runs with `npx convex run`) on convex-test's backend: planted kind-less
- * rows of each label are stamped with exactly the kind `isPinnableVersion` reads them as,
- * a row that names a kind is untouched, pinnability is unchanged for every row, a second
- * run stamps 0, and above the documented bound the run refuses whole.
- */
-
-const modules = {
-  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
-  './_generated/api.ts': async () => ({}),
-}
-const stampVersionKinds = makeFunctionReference<'mutation'>('cms:stampVersionKinds')
-
-const STAMP = '2026-10-29T00:00:00.000Z'
-const snapshot = (id: string) =>
-  foldDocument({ collection: 'page', id, values: { title: id } } as unknown as CmsDocument)
-
-/** The planted rows: kind-less of each label, and two that name a kind. */
-const PLANTED = [
-  { docId: 'a', version: 1, label: 'published' },
-  { docId: 'a', version: 2, label: 'pre-restore' },
-  { docId: 'a', version: 3, label: 'AI snapshot' },
-  { docId: 'b', version: 1 },
-  { docId: 'b', version: 2, label: 'published', kind: 'snapshot' as const },
-  { docId: 'b', version: 3, label: 'pre-restore', kind: 'publish' as const },
-]
-
-async function plant(
-  rows: ReadonlyArray<{ docId: string; version: number; label?: string; kind?: 'publish' | 'snapshot' }>,
-) {
-  const t = convexTest(schema, modules)
-  await t.run(async (ctx) => {
-    for (const row of rows) {
-      await ctx.db.insert('documentVersions', {
-        collection: 'page',
-        snapshot: snapshot(row.docId),
-        createdAt: STAMP,
-        ...row,
-      })
-    }
-  })
-  return t
-}
-
-const stored = (t: Awaited<ReturnType<typeof plant>>) =>
-  t.run(async (ctx) =>
-    (await ctx.db.query('documentVersions').collect()).sort((x, y) =>
-      x.docId + x.version < y.docId + y.version ? -1 : 1,
-    ),
-  )
-
-describe('EC-707 — cms:stampVersionKinds stamps what isPinnableVersion infers, once', () => {
-  it('stamps every kind-less row by its label, leaves a kinded row alone, keeps pinnability; a second run stamps 0', async () => {
-    const t = await plant(PLANTED)
-    const before = await stored(t)
-    expect(before.filter((row) => row.kind === undefined)).toHaveLength(4)
-
-    expect(await t.mutation(stampVersionKinds, {})).toEqual({ scanned: 6, stamped: 4 })
-    const after = await stored(t)
-    expect(after.map((row) => `${row.docId}@v${row.version} ${row.kind}`)).toEqual([
-      'a@v1 publish',
-      'a@v2 snapshot',
-      'a@v3 snapshot',
-      'b@v1 snapshot',
-      'b@v2 snapshot', // named a kind: untouched (its label says published, its kind wins)
-      'b@v3 publish',
-    ])
-    // The migration preserves meaning: every row pins exactly as it did kind-less.
-    expect(after.map(isPinnableVersion)).toEqual(before.map(isPinnableVersion))
-    // Nothing but `kind` was written: label, snapshot (still folded), createdAt as planted.
-    for (const [index, row] of after.entries()) {
-      const { kind: _k, ...rest } = row
-      const { kind: _b, ...was } = before[index]!
-      expect(rest).toEqual(was)
-    }
-    // The at-rest scan now reads 0 kind-less rows here.
-    const scan = scanStoredShapes({ cmsDocuments: [], documentVersions: after }, { collections: [] })
-    expect(scan.byShape['kind-less-version']).toBe(0)
-
-    expect(await t.mutation(stampVersionKinds, {})).toEqual({ scanned: 6, stamped: 0 })
-  })
-
-  it('CONTROL: before the stamping the at-rest scan counts the kind-less rows (the scan can see them)', async () => {
-    const t = await plant(PLANTED)
-    const scan = scanStoredShapes({ cmsDocuments: [], documentVersions: await stored(t) }, { collections: [] })
-    expect(scan.byShape['kind-less-version']).toBe(4)
-  })
-
-  it('refuses WHOLE above the documented row bound — nothing stamped', async () => {
-    const rows = Array.from({ length: VERSION_KIND_STAMP_BOUND.rows + 1 }, (_, index) => ({
-      docId: 'c',
-      version: index + 1,
-      label: 'published',
-    }))
-    const t = await plant(rows)
-    await expect(t.mutation(stampVersionKinds, {})).rejects.toThrow(
-      /exceed the one-transaction stamping bound of 4096 — nothing was stamped/,
-    )
-    const after = await stored(t)
-    expect(after.every((row) => row.kind === undefined)).toBe(true)
-  }, 60_000)
-})