@payloadcms/drizzle 4.0.0-canary.37 → 4.0.0-canary.39

package/dist/postgres/predefinedMigrations/sizes-to-variants/index.js

@@ -0,0 +1,185 @@
+import { sql } from 'drizzle-orm';
+import { assertNoSizesToVariantsColumnCollisions, buildGeneratedLegacyIndexName, getSizesToVariantsRenames, isGeneratedLegacyIndexName } from '../../../utilities/getSizesToVariantsRenames.js';
+/**
+ * Moves every upload collection's stored image sizes between the legacy `sizes_*` columns and
+ * `variants_*` (main and versions tables), renaming each column in place so no data is copied,
+ * then renames the indexes on those columns to what the current schema expects. Skips columns
+ * that are already renamed, so it's safe to re-run.
+ */ export async function migratePostgresSizesToVariants({ db, direction = 'up', payload }) {
+    const adapter = payload.db;
+    const schemaName = adapter.schemaName || 'public';
+    const plan = getSizesToVariantsRenames({
+        adapter,
+        direction
+    });
+    const plannedTables = [];
+    for (const tablePlan of plan){
+        const existingColumns = await getColumnNames({
+            db,
+            schemaName,
+            tableName: tablePlan.tableName
+        });
+        assertNoSizesToVariantsColumnCollisions({
+            columns: tablePlan.columns,
+            existingColumns,
+            tableName: tablePlan.tableName
+        });
+        plannedTables.push({
+            ...tablePlan,
+            existingColumns
+        });
+    }
+    const reservedRelationNames = direction === 'down' ? await getPostgresSchemaRelationNames({
+        db,
+        schemaName
+    }) : undefined;
+    for (const { columns, existingColumns, indexes, tableName } of plannedTables){
+        let renamedCount = 0;
+        for (const { from, to } of columns){
+            if (!existingColumns.has(from) || existingColumns.has(to)) {
+                continue;
+            }
+            await db.execute(sql`
+        ALTER TABLE ${sql.identifier(schemaName)}.${sql.identifier(tableName)}
+        RENAME COLUMN ${sql.identifier(from)} TO ${sql.identifier(to)}
+      `);
+            renamedCount++;
+        }
+        const existingIndexes = await getIndexes({
+            db,
+            schemaName,
+            tableName
+        });
+        for (const plannedIndex of indexes){
+            const index = reservedRelationNames && plannedIndex.legacyNameBase ? {
+                ...plannedIndex,
+                to: reservePostgresLegacyIndexName({
+                    existingIndexes,
+                    index: plannedIndex,
+                    reservedRelationNames
+                })
+            } : plannedIndex;
+            const existingName = resolvePostgresIndexRename({
+                existingIndexes,
+                index,
+                tableName
+            });
+            if (!existingName) {
+                continue;
+            }
+            await db.execute(sql`
+        ALTER INDEX ${sql.identifier(schemaName)}.${sql.identifier(existingName)}
+        RENAME TO ${sql.identifier(index.to)}
+      `);
+        }
+        payload.logger.info({
+            msg: `sizes-to-variants (${direction}): renamed ${renamedCount} column(s) on "${tableName}"`
+        });
+    }
+}
+export function reservePostgresLegacyIndexName({ existingIndexes, index, reservedRelationNames }) {
+    const { legacyNameBase } = index;
+    if (!legacyNameBase) {
+        reservedRelationNames.add(index.to);
+        return index.to;
+    }
+    const existingDestination = existingIndexes.find((existingIndex)=>isCompatiblePostgresIndex({
+            existingIndex,
+            index
+        }) && isGeneratedLegacyIndexName({
+            indexName: existingIndex.name,
+            legacyNameBase
+        }));
+    if (existingDestination) {
+        reservedRelationNames.add(existingDestination.name);
+        return existingDestination.name;
+    }
+    let number = 0;
+    let indexName = buildGeneratedLegacyIndexName(legacyNameBase);
+    while(reservedRelationNames.has(indexName)){
+        number++;
+        indexName = buildGeneratedLegacyIndexName(legacyNameBase, number);
+    }
+    reservedRelationNames.add(indexName);
+    return indexName;
+}
+export function resolvePostgresIndexRename({ existingIndexes, index, tableName }) {
+    const destinationIndex = existingIndexes.find(({ name })=>name === index.to);
+    if (destinationIndex) {
+        if (!isCompatiblePostgresIndex({
+            existingIndex: destinationIndex,
+            index
+        })) {
+            throw new Error(`Cannot run the sizes-to-variants migration because index "${index.to}" on table "${tableName}" does not match the expected columns, uniqueness, or predicate.`);
+        }
+        return undefined;
+    }
+    let sourceIndex;
+    const { legacyNameBase } = index;
+    if (index.from) {
+        sourceIndex = existingIndexes.find(({ name })=>name === index.from);
+    } else if (legacyNameBase) {
+        const legacyCandidates = existingIndexes.filter((existingIndex)=>isGeneratedLegacyIndexName({
+                indexName: existingIndex.name,
+                legacyNameBase
+            }));
+        sourceIndex = legacyCandidates.find((existingIndex)=>isCompatiblePostgresIndex({
+                existingIndex,
+                index
+            })) ?? legacyCandidates[0];
+    }
+    if (!sourceIndex) {
+        return undefined;
+    }
+    if (!isCompatiblePostgresIndex({
+        existingIndex: sourceIndex,
+        index
+    })) {
+        throw new Error(`Cannot run the sizes-to-variants migration because index "${sourceIndex.name}" on table "${tableName}" does not match the expected columns, uniqueness, or predicate.`);
+    }
+    return sourceIndex.name === index.to ? undefined : sourceIndex.name;
+}
+function isCompatiblePostgresIndex({ existingIndex, index }) {
+    return existingIndex.columns.join(',') === index.columns.join(',') && existingIndex.unique === index.unique && !existingIndex.isPartial;
+}
+async function getColumnNames({ db, schemaName, tableName }) {
+    const result = await db.execute(sql`
+    SELECT column_name FROM information_schema.columns
+    WHERE table_schema = ${schemaName} AND table_name = ${tableName}
+  `);
+    return new Set(result.rows.map((row)=>row.column_name));
+}
+async function getIndexes({ db, schemaName, tableName }) {
+    const result = await db.execute(sql`
+    SELECT
+      i.relname AS name,
+      array_agg(a.attname::text ORDER BY k.ord) AS columns,
+      ix.indisunique AS is_unique,
+      ix.indpred IS NOT NULL AS is_partial
+    FROM pg_index ix
+    JOIN pg_class t ON t.oid = ix.indrelid
+    JOIN pg_namespace n ON n.oid = t.relnamespace
+    JOIN pg_class i ON i.oid = ix.indexrelid
+    CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord)
+    JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+    WHERE n.nspname = ${schemaName} AND t.relname = ${tableName}
+    GROUP BY i.relname, ix.indisunique, (ix.indpred IS NOT NULL)
+  `);
+    return result.rows.map((row)=>({
+            name: row.name,
+            columns: row.columns,
+            isPartial: row.is_partial,
+            unique: row.is_unique
+        }));
+}
+export async function getPostgresSchemaRelationNames({ db, schemaName }) {
+    const result = await db.execute(sql`
+    SELECT c.relname AS name
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = ${schemaName}
+  `);
+    return new Set(result.rows.map((row)=>row.name));
+}
+
+//# sourceMappingURL=index.js.map

package/dist/postgres/predefinedMigrations/sizes-to-variants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/postgres/predefinedMigrations/sizes-to-variants/index.ts"],"sourcesContent":["import type { Payload } from 'payload'\n\nimport { sql } from 'drizzle-orm'\n\nimport type {\n  SizesToVariantsDirection,\n  SizesToVariantsIndexRename,\n} from '../../../utilities/getSizesToVariantsRenames.js'\nimport type { BasePostgresAdapter } from '../../types.js'\n\nimport {\n  assertNoSizesToVariantsColumnCollisions,\n  buildGeneratedLegacyIndexName,\n  getSizesToVariantsRenames,\n  isGeneratedLegacyIndexName,\n} from '../../../utilities/getSizesToVariantsRenames.js'\n\ntype ExistingPostgresIndex = {\n  columns: string[]\n  isPartial: boolean\n  name: string\n  unique: boolean\n}\n\n/**\n * Moves every upload collection's stored image sizes between the legacy `sizes_*` columns and\n * `variants_*` (main and versions tables), renaming each column in place so no data is copied,\n * then renames the indexes on those columns to what the current schema expects. Skips columns\n * that are already renamed, so it's safe to re-run.\n */\nexport async function migratePostgresSizesToVariants({\n  db,\n  direction = 'up',\n  payload,\n}: {\n  db: any\n  direction?: SizesToVariantsDirection\n  payload: Payload\n}): Promise<void> {\n  const adapter = payload.db as unknown as BasePostgresAdapter\n  const schemaName = adapter.schemaName || 'public'\n  const plan = getSizesToVariantsRenames({ adapter, direction })\n  const plannedTables: Array<\n    (typeof plan)[number] & {\n      existingColumns: Set<string>\n    }\n  > = []\n\n  for (const tablePlan of plan) {\n    const existingColumns = await getColumnNames({\n      db,\n      schemaName,\n      tableName: tablePlan.tableName,\n    })\n\n    assertNoSizesToVariantsColumnCollisions({\n      columns: tablePlan.columns,\n      existingColumns,\n      tableName: tablePlan.tableName,\n    })\n\n    plannedTables.push({ ...tablePlan, existingColumns })\n  }\n\n  const reservedRelationNames =\n    direction === 'down' ? await getPostgresSchemaRelationNames({ db, schemaName }) : undefined\n\n  for (const { columns, existingColumns, indexes, tableName } of plannedTables) {\n    let renamedCount = 0\n\n    for (const { from, to } of columns) {\n      if (!existingColumns.has(from) || existingColumns.has(to)) {\n        continue\n      }\n\n      await db.execute(sql`\n        ALTER TABLE ${sql.identifier(schemaName)}.${sql.identifier(tableName)}\n        RENAME COLUMN ${sql.identifier(from)} TO ${sql.identifier(to)}\n      `)\n      renamedCount++\n    }\n\n    const existingIndexes = await getIndexes({ db, schemaName, tableName })\n\n    for (const plannedIndex of indexes) {\n      const index =\n        reservedRelationNames && plannedIndex.legacyNameBase\n          ? {\n              ...plannedIndex,\n              to: reservePostgresLegacyIndexName({\n                existingIndexes,\n                index: plannedIndex,\n                reservedRelationNames,\n              }),\n            }\n          : plannedIndex\n      const existingName = resolvePostgresIndexRename({\n        existingIndexes,\n        index,\n        tableName,\n      })\n\n      if (!existingName) {\n        continue\n      }\n\n      await db.execute(sql`\n        ALTER INDEX ${sql.identifier(schemaName)}.${sql.identifier(existingName)}\n        RENAME TO ${sql.identifier(index.to)}\n      `)\n    }\n\n    payload.logger.info({\n      msg: `sizes-to-variants (${direction}): renamed ${renamedCount} column(s) on \"${tableName}\"`,\n    })\n  }\n}\n\nexport function reservePostgresLegacyIndexName({\n  existingIndexes,\n  index,\n  reservedRelationNames,\n}: {\n  existingIndexes: ExistingPostgresIndex[]\n  index: SizesToVariantsIndexRename\n  reservedRelationNames: Set<string>\n}): string {\n  const { legacyNameBase } = index\n\n  if (!legacyNameBase) {\n    reservedRelationNames.add(index.to)\n    return index.to\n  }\n\n  const existingDestination = existingIndexes.find(\n    (existingIndex) =>\n      isCompatiblePostgresIndex({ existingIndex, index }) &&\n      isGeneratedLegacyIndexName({\n        indexName: existingIndex.name,\n        legacyNameBase,\n      }),\n  )\n\n  if (existingDestination) {\n    reservedRelationNames.add(existingDestination.name)\n    return existingDestination.name\n  }\n\n  let number = 0\n  let indexName = buildGeneratedLegacyIndexName(legacyNameBase)\n\n  while (reservedRelationNames.has(indexName)) {\n    number++\n    indexName = buildGeneratedLegacyIndexName(legacyNameBase, number)\n  }\n\n  reservedRelationNames.add(indexName)\n  return indexName\n}\n\nexport function resolvePostgresIndexRename({\n  existingIndexes,\n  index,\n  tableName,\n}: {\n  existingIndexes: ExistingPostgresIndex[]\n  index: SizesToVariantsIndexRename\n  tableName: string\n}): string | undefined {\n  const destinationIndex = existingIndexes.find(({ name }) => name === index.to)\n\n  if (destinationIndex) {\n    if (!isCompatiblePostgresIndex({ existingIndex: destinationIndex, index })) {\n      throw new Error(\n        `Cannot run the sizes-to-variants migration because index \"${index.to}\" on table \"${tableName}\" does not match the expected columns, uniqueness, or predicate.`,\n      )\n    }\n\n    return undefined\n  }\n\n  let sourceIndex: ExistingPostgresIndex | undefined\n  const { legacyNameBase } = index\n\n  if (index.from) {\n    sourceIndex = existingIndexes.find(({ name }) => name === index.from)\n  } else if (legacyNameBase) {\n    const legacyCandidates = existingIndexes.filter((existingIndex) =>\n      isGeneratedLegacyIndexName({\n        indexName: existingIndex.name,\n        legacyNameBase,\n      }),\n    )\n\n    sourceIndex =\n      legacyCandidates.find((existingIndex) =>\n        isCompatiblePostgresIndex({ existingIndex, index }),\n      ) ?? legacyCandidates[0]\n  }\n\n  if (!sourceIndex) {\n    return undefined\n  }\n\n  if (!isCompatiblePostgresIndex({ existingIndex: sourceIndex, index })) {\n    throw new Error(\n      `Cannot run the sizes-to-variants migration because index \"${sourceIndex.name}\" on table \"${tableName}\" does not match the expected columns, uniqueness, or predicate.`,\n    )\n  }\n\n  return sourceIndex.name === index.to ? undefined : sourceIndex.name\n}\n\nfunction isCompatiblePostgresIndex({\n  existingIndex,\n  index,\n}: {\n  existingIndex: ExistingPostgresIndex\n  index: SizesToVariantsIndexRename\n}): boolean {\n  return (\n    existingIndex.columns.join(',') === index.columns.join(',') &&\n    existingIndex.unique === index.unique &&\n    !existingIndex.isPartial\n  )\n}\n\nasync function getColumnNames({\n  db,\n  schemaName,\n  tableName,\n}: {\n  db: any\n  schemaName: string\n  tableName: string\n}): Promise<Set<string>> {\n  const result = await db.execute(sql`\n    SELECT column_name FROM information_schema.columns\n    WHERE table_schema = ${schemaName} AND table_name = ${tableName}\n  `)\n\n  return new Set(result.rows.map((row: { column_name: string }) => row.column_name))\n}\n\nasync function getIndexes({\n  db,\n  schemaName,\n  tableName,\n}: {\n  db: any\n  schemaName: string\n  tableName: string\n}): Promise<ExistingPostgresIndex[]> {\n  const result = await db.execute(sql`\n    SELECT\n      i.relname AS name,\n      array_agg(a.attname::text ORDER BY k.ord) AS columns,\n      ix.indisunique AS is_unique,\n      ix.indpred IS NOT NULL AS is_partial\n    FROM pg_index ix\n    JOIN pg_class t ON t.oid = ix.indrelid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    JOIN pg_class i ON i.oid = ix.indexrelid\n    CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord)\n    JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum\n    WHERE n.nspname = ${schemaName} AND t.relname = ${tableName}\n    GROUP BY i.relname, ix.indisunique, (ix.indpred IS NOT NULL)\n  `)\n\n  return result.rows.map(\n    (row: { columns: string[]; is_partial: boolean; is_unique: boolean; name: string }) => ({\n      name: row.name,\n      columns: row.columns,\n      isPartial: row.is_partial,\n      unique: row.is_unique,\n    }),\n  )\n}\n\nexport async function getPostgresSchemaRelationNames({\n  db,\n  schemaName,\n}: {\n  db: any\n  schemaName: string\n}): Promise<Set<string>> {\n  const result = await db.execute(sql`\n    SELECT c.relname AS name\n    FROM pg_class c\n    JOIN pg_namespace n ON n.oid = c.relnamespace\n    WHERE n.nspname = ${schemaName}\n  `)\n\n  return new Set(result.rows.map((row: { name: string }) => row.name))\n}\n"],"names":["sql","assertNoSizesToVariantsColumnCollisions","buildGeneratedLegacyIndexName","getSizesToVariantsRenames","isGeneratedLegacyIndexName","migratePostgresSizesToVariants","db","direction","payload","adapter","schemaName","plan","plannedTables","tablePlan","existingColumns","getColumnNames","tableName","columns","push","reservedRelationNames","getPostgresSchemaRelationNames","undefined","indexes","renamedCount","from","to","has","execute","identifier","existingIndexes","getIndexes","plannedIndex","index","legacyNameBase","reservePostgresLegacyIndexName","existingName","resolvePostgresIndexRename","logger","info","msg","add","existingDestination","find","existingIndex","isCompatiblePostgresIndex","indexName","name","number","destinationIndex","Error","sourceIndex","legacyCandidates","filter","join","unique","isPartial","result","Set","rows","map","row","column_name","is_partial","is_unique"],"mappings":"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"}

package/dist/sqlite/predefinedMigrations/sizes-to-variants/index.d.ts

@@ -0,0 +1,15 @@
+import type { Payload } from 'payload';
+import type { SizesToVariantsDirection } from '../../../utilities/getSizesToVariantsRenames.js';
+/**
+ * Moves every upload collection's stored image sizes between the legacy `sizes_*` columns and
+ * `variants_*` (main and versions tables), renaming each column in place so no data is copied.
+ * SQLite can't rename an index, so each index on a renamed column is dropped and recreated under
+ * the name the current schema expects. Skips columns that are already renamed, so it's safe to
+ * re-run.
+ */
+export declare function migrateSqliteSizesToVariants({ db, direction, payload, }: {
+    db: any;
+    direction?: SizesToVariantsDirection;
+    payload: Payload;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/sqlite/predefinedMigrations/sizes-to-variants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/predefinedMigrations/sizes-to-variants/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAKtC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAA;AAQ/F;;;;;;GAMG;AACH,wBAAsB,4BAA4B,CAAC,EACjD,EAAE,EACF,SAAgB,EAChB,OAAO,GACR,EAAE;IACD,EAAE,EAAE,GAAG,CAAA;IACP,SAAS,CAAC,EAAE,wBAAwB,CAAA;IACpC,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8FhB"}

package/dist/sqlite/predefinedMigrations/sizes-to-variants/index.js

@@ -0,0 +1,114 @@
+import { sql } from 'drizzle-orm';
+import { assertNoSizesToVariantsColumnCollisions, getSizesToVariantsRenames, isGeneratedLegacyIndexName } from '../../../utilities/getSizesToVariantsRenames.js';
+/**
+ * Moves every upload collection's stored image sizes between the legacy `sizes_*` columns and
+ * `variants_*` (main and versions tables), renaming each column in place so no data is copied.
+ * SQLite can't rename an index, so each index on a renamed column is dropped and recreated under
+ * the name the current schema expects. Skips columns that are already renamed, so it's safe to
+ * re-run.
+ */ export async function migrateSqliteSizesToVariants({ db, direction = 'up', payload }) {
+    const adapter = payload.db;
+    const plan = getSizesToVariantsRenames({
+        adapter,
+        direction
+    });
+    const plannedTables = [];
+    for (const tablePlan of plan){
+        const existingColumns = await getColumnNames({
+            db,
+            tableName: tablePlan.tableName
+        });
+        assertNoSizesToVariantsColumnCollisions({
+            columns: tablePlan.columns,
+            existingColumns,
+            tableName: tablePlan.tableName
+        });
+        plannedTables.push({
+            ...tablePlan,
+            existingColumns
+        });
+    }
+    for (const { columns, existingColumns, indexes, tableName } of plannedTables){
+        const columnsAfterRename = new Set(existingColumns);
+        let renamedCount = 0;
+        for (const { from, to } of columns){
+            if (!existingColumns.has(from) || existingColumns.has(to)) {
+                continue;
+            }
+            columnsAfterRename.delete(from);
+            columnsAfterRename.add(to);
+            await db.run(sql`
+        ALTER TABLE ${sql.identifier(tableName)}
+        RENAME COLUMN ${sql.identifier(from)} TO ${sql.identifier(to)}
+      `);
+            renamedCount++;
+        }
+        const existingIndexes = await getIndexes({
+            db,
+            tableName
+        });
+        for (const index of indexes){
+            if (!index.columns.every((column)=>columnsAfterRename.has(column))) {
+                continue;
+            }
+            const destinationIndex = existingIndexes.find(({ name })=>name === index.to);
+            const sourceIndex = destinationIndex ? undefined : index.from ? existingIndexes.find(({ name })=>name === index.from) : index.legacyNameBase ? existingIndexes.find(({ name, columns })=>columns.join(',') === index.columns.join(',') && isGeneratedLegacyIndexName({
+                    indexName: name,
+                    legacyNameBase: index.legacyNameBase
+                })) : undefined;
+            if (destinationIndex) {
+                if (destinationIndex.columns.join(',') !== index.columns.join(',') || destinationIndex.unique !== index.unique) {
+                    throw new Error(`Cannot run the sizes-to-variants migration because index "${index.to}" on table "${tableName}" does not match the expected columns or uniqueness.`);
+                }
+            } else {
+                const unique = index.unique ? sql.raw('UNIQUE ') : sql.empty();
+                const columnList = sql.join(index.columns.map((column)=>sql.identifier(column)), sql.raw(', '));
+                await db.run(sql`
+          CREATE ${unique}INDEX ${sql.identifier(index.to)}
+          ON ${sql.identifier(tableName)} (${columnList})
+        `);
+            }
+            if (sourceIndex && sourceIndex.name !== index.to) {
+                await db.run(sql`DROP INDEX ${sql.identifier(sourceIndex.name)}`);
+            }
+        }
+        payload.logger.info({
+            msg: `sizes-to-variants (${direction}): renamed ${renamedCount} column(s) on "${tableName}"`
+        });
+    }
+}
+async function getColumnNames({ db, tableName }) {
+    const rows = await db.all(sql`SELECT name FROM pragma_table_info(${tableName})`);
+    return new Set(rows.map(({ name })=>name));
+}
+async function getIndexes({ db, tableName }) {
+    // `origin = 'c'` keeps only `CREATE INDEX` indexes, skipping SQLite's internal autoindexes.
+    const rows = await db.all(sql`
+      SELECT
+        il.name AS index_name,
+        il."unique" AS is_unique,
+        ii.name AS column_name,
+        ii.seqno AS seqno
+      FROM pragma_index_list(${tableName}) AS il
+      JOIN pragma_index_info(il.name) AS ii
+      WHERE il.origin = 'c'
+      ORDER BY il.name, ii.seqno
+    `);
+    const indexes = new Map();
+    for (const { column_name, index_name, is_unique } of rows){
+        const index = indexes.get(index_name) ?? {
+            columns: [],
+            unique: Boolean(is_unique)
+        };
+        index.columns.push(column_name);
+        indexes.set(index_name, index);
+    }
+    return [
+        ...indexes
+    ].map(([name, index])=>({
+            name,
+            ...index
+        }));
+}
+
+//# sourceMappingURL=index.js.map

package/dist/sqlite/predefinedMigrations/sizes-to-variants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/sqlite/predefinedMigrations/sizes-to-variants/index.ts"],"sourcesContent":["import type { Payload } from 'payload'\n\nimport { sql } from 'drizzle-orm'\n\nimport type { DrizzleAdapter } from '../../../types.js'\nimport type { SizesToVariantsDirection } from '../../../utilities/getSizesToVariantsRenames.js'\n\nimport {\n  assertNoSizesToVariantsColumnCollisions,\n  getSizesToVariantsRenames,\n  isGeneratedLegacyIndexName,\n} from '../../../utilities/getSizesToVariantsRenames.js'\n\n/**\n * Moves every upload collection's stored image sizes between the legacy `sizes_*` columns and\n * `variants_*` (main and versions tables), renaming each column in place so no data is copied.\n * SQLite can't rename an index, so each index on a renamed column is dropped and recreated under\n * the name the current schema expects. Skips columns that are already renamed, so it's safe to\n * re-run.\n */\nexport async function migrateSqliteSizesToVariants({\n  db,\n  direction = 'up',\n  payload,\n}: {\n  db: any\n  direction?: SizesToVariantsDirection\n  payload: Payload\n}): Promise<void> {\n  const adapter = payload.db as unknown as DrizzleAdapter\n  const plan = getSizesToVariantsRenames({ adapter, direction })\n  const plannedTables: Array<\n    (typeof plan)[number] & {\n      existingColumns: Set<string>\n    }\n  > = []\n\n  for (const tablePlan of plan) {\n    const existingColumns = await getColumnNames({ db, tableName: tablePlan.tableName })\n\n    assertNoSizesToVariantsColumnCollisions({\n      columns: tablePlan.columns,\n      existingColumns,\n      tableName: tablePlan.tableName,\n    })\n\n    plannedTables.push({ ...tablePlan, existingColumns })\n  }\n\n  for (const { columns, existingColumns, indexes, tableName } of plannedTables) {\n    const columnsAfterRename = new Set(existingColumns)\n    let renamedCount = 0\n\n    for (const { from, to } of columns) {\n      if (!existingColumns.has(from) || existingColumns.has(to)) {\n        continue\n      }\n\n      columnsAfterRename.delete(from)\n      columnsAfterRename.add(to)\n\n      await db.run(sql`\n        ALTER TABLE ${sql.identifier(tableName)}\n        RENAME COLUMN ${sql.identifier(from)} TO ${sql.identifier(to)}\n      `)\n      renamedCount++\n    }\n\n    const existingIndexes = await getIndexes({ db, tableName })\n\n    for (const index of indexes) {\n      if (!index.columns.every((column) => columnsAfterRename.has(column))) {\n        continue\n      }\n\n      const destinationIndex = existingIndexes.find(({ name }) => name === index.to)\n      const sourceIndex = destinationIndex\n        ? undefined\n        : index.from\n          ? existingIndexes.find(({ name }) => name === index.from)\n          : index.legacyNameBase\n            ? existingIndexes.find(\n                ({ name, columns }) =>\n                  columns.join(',') === index.columns.join(',') &&\n                  isGeneratedLegacyIndexName({\n                    indexName: name,\n                    legacyNameBase: index.legacyNameBase,\n                  }),\n              )\n            : undefined\n\n      if (destinationIndex) {\n        if (\n          destinationIndex.columns.join(',') !== index.columns.join(',') ||\n          destinationIndex.unique !== index.unique\n        ) {\n          throw new Error(\n            `Cannot run the sizes-to-variants migration because index \"${index.to}\" on table \"${tableName}\" does not match the expected columns or uniqueness.`,\n          )\n        }\n      } else {\n        const unique = index.unique ? sql.raw('UNIQUE ') : sql.empty()\n        const columnList = sql.join(\n          index.columns.map((column) => sql.identifier(column)),\n          sql.raw(', '),\n        )\n\n        await db.run(sql`\n          CREATE ${unique}INDEX ${sql.identifier(index.to)}\n          ON ${sql.identifier(tableName)} (${columnList})\n        `)\n      }\n\n      if (sourceIndex && sourceIndex.name !== index.to) {\n        await db.run(sql`DROP INDEX ${sql.identifier(sourceIndex.name)}`)\n      }\n    }\n\n    payload.logger.info({\n      msg: `sizes-to-variants (${direction}): renamed ${renamedCount} column(s) on \"${tableName}\"`,\n    })\n  }\n}\n\nasync function getColumnNames({\n  db,\n  tableName,\n}: {\n  db: any\n  tableName: string\n}): Promise<Set<string>> {\n  const rows: { name: string }[] = await db.all(\n    sql`SELECT name FROM pragma_table_info(${tableName})`,\n  )\n\n  return new Set(rows.map(({ name }) => name))\n}\n\nasync function getIndexes({\n  db,\n  tableName,\n}: {\n  db: any\n  tableName: string\n}): Promise<{ columns: string[]; name: string; unique: boolean }[]> {\n  // `origin = 'c'` keeps only `CREATE INDEX` indexes, skipping SQLite's internal autoindexes.\n  const rows: { column_name: string; index_name: string; is_unique: number; seqno: number }[] =\n    await db.all(sql`\n      SELECT\n        il.name AS index_name,\n        il.\"unique\" AS is_unique,\n        ii.name AS column_name,\n        ii.seqno AS seqno\n      FROM pragma_index_list(${tableName}) AS il\n      JOIN pragma_index_info(il.name) AS ii\n      WHERE il.origin = 'c'\n      ORDER BY il.name, ii.seqno\n    `)\n\n  const indexes = new Map<string, { columns: string[]; unique: boolean }>()\n\n  for (const { column_name, index_name, is_unique } of rows) {\n    const index = indexes.get(index_name) ?? { columns: [], unique: Boolean(is_unique) }\n\n    index.columns.push(column_name)\n    indexes.set(index_name, index)\n  }\n\n  return [...indexes].map(([name, index]) => ({ name, ...index }))\n}\n"],"names":["sql","assertNoSizesToVariantsColumnCollisions","getSizesToVariantsRenames","isGeneratedLegacyIndexName","migrateSqliteSizesToVariants","db","direction","payload","adapter","plan","plannedTables","tablePlan","existingColumns","getColumnNames","tableName","columns","push","indexes","columnsAfterRename","Set","renamedCount","from","to","has","delete","add","run","identifier","existingIndexes","getIndexes","index","every","column","destinationIndex","find","name","sourceIndex","undefined","legacyNameBase","join","indexName","unique","Error","raw","empty","columnList","map","logger","info","msg","rows","all","Map","column_name","index_name","is_unique","get","Boolean","set"],"mappings":"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"}

package/dist/utilities/buildDynamicPredefinedSizesToVariantsMigration.d.ts

@@ -0,0 +1,15 @@
+import type { DynamicMigrationTemplate } from 'payload';
+/**
+ * Builds the `sizes-to-variants` predefined migration for a SQL adapter. The migration renames
+ * columns rather than letting drizzle-kit diff the schema (which would drop and re-add them,
+ * losing every stored image size).
+ *
+ * It also writes a schema snapshot: the project's previous snapshot with only these renames
+ * applied. The next generated migration then diffs from the renamed columns instead of dropping
+ * them, and still picks up every other schema change the upgrade brings. Without a previous
+ * snapshot (a project that has only ever used `push`) there's nothing to update, so none is written.
+ */
+export declare const buildDynamicPredefinedSizesToVariantsMigration: ({ packageName, }: {
+    packageName: string;
+}) => DynamicMigrationTemplate;
+//# sourceMappingURL=buildDynamicPredefinedSizesToVariantsMigration.d.ts.map

package/dist/utilities/buildDynamicPredefinedSizesToVariantsMigration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildDynamicPredefinedSizesToVariantsMigration.d.ts","sourceRoot":"","sources":["../../src/utilities/buildDynamicPredefinedSizesToVariantsMigration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AA+BvD;;;;;;;;;GASG;AACH,eAAO,MAAM,8CAA8C,qBAExD;IACD,WAAW,EAAE,MAAM,CAAA;CACpB,KAAG,wBAoBH,CAAA"}

package/dist/utilities/buildDynamicPredefinedSizesToVariantsMigration.js

@@ -0,0 +1,110 @@
+import { randomUUID } from 'crypto';
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+import { findSizesToVariantsFieldCollision, getSizesToVariantsRenames } from './getSizesToVariantsRenames.js';
+/**
+ * Builds the `sizes-to-variants` predefined migration for a SQL adapter. The migration renames
+ * columns rather than letting drizzle-kit diff the schema (which would drop and re-add them,
+ * losing every stored image size).
+ *
+ * It also writes a schema snapshot: the project's previous snapshot with only these renames
+ * applied. The next generated migration then diffs from the renamed columns instead of dropping
+ * them, and still picks up every other schema change the upgrade brings. Without a previous
+ * snapshot (a project that has only ever used `push`) there's nothing to update, so none is written.
+ */ export const buildDynamicPredefinedSizesToVariantsMigration = ({ packageName })=>{
+    return async ({ filePath, payload })=>{
+        const adapter = payload.db;
+        const previousSnapshot = await readLatestSnapshot({
+            adapter
+        });
+        if (previousSnapshot) {
+            const renamedSnapshot = applySizesToVariantsRenames({
+                plan: getSizesToVariantsRenames({
+                    adapter,
+                    direction: 'up'
+                }),
+                snapshot: previousSnapshot
+            });
+            writeFileSync(`${filePath}.json`, JSON.stringify(renamedSnapshot, null, 2));
+        }
+        return {
+            downSQL: `  await migrateSizesToVariants({ db, direction: 'down', payload })`,
+            imports: `import { migrateSizesToVariants } from '${packageName}/migration-utils'`,
+            upSQL: `  await migrateSizesToVariants({ db, payload })`
+        };
+    };
+};
+/** The latest snapshot in the migrations directory, upgraded to drizzle-kit's current format. */ async function readLatestSnapshot({ adapter }) {
+    const dir = adapter.migrationDir;
+    const latestSnapshotFile = readdirSync(dir).filter((file)=>file.endsWith('.json')).sort().reverse()[0];
+    if (!latestSnapshotFile) {
+        return undefined;
+    }
+    const { generateDrizzleJson, upSnapshot } = adapter.requireDrizzleKit();
+    const currentVersion = (await generateDrizzleJson(adapter.schema)).version;
+    const snapshot = JSON.parse(readFileSync(`${dir}/${latestSnapshotFile}`, 'utf8'));
+    return upSnapshot && snapshot.version < currentVersion ? upSnapshot(snapshot) : snapshot;
+}
+function applySizesToVariantsRenames({ plan, snapshot }) {
+    const renamed = structuredClone(snapshot);
+    for (const { columns, indexes, tableName } of plan){
+        const table = Object.values(renamed.tables).find(({ name })=>name === tableName);
+        if (!table) {
+            continue;
+        }
+        const existingColumns = new Set(Object.values(table.columns).map(({ name })=>name));
+        for (const { from, to } of columns){
+            if (existingColumns.has(from) && existingColumns.has(to)) {
+                throw new Error(`Cannot create the sizes-to-variants migration because snapshot table "${tableName}" contains both "${from}" and "${to}". Move or rename the existing destination data before creating this migration.`);
+            }
+        }
+        const fieldCollision = findSizesToVariantsFieldCollision({
+            columns,
+            existingColumns
+        });
+        if (fieldCollision) {
+            throw new Error(`Cannot create the sizes-to-variants migration because snapshot table "${tableName}" contains both the "${fieldCollision.from}" and "${fieldCollision.to}" fields. Move or rename the existing destination data before creating this migration.`);
+        }
+        for (const { from, to } of columns){
+            const column = table.columns[from];
+            if (column) {
+                if (table.columns[to]) {
+                    throw new Error(`Cannot create the sizes-to-variants migration because snapshot table "${tableName}" contains both "${from}" and "${to}". Move or rename the existing destination data before creating this migration.`);
+                }
+                delete table.columns[from];
+                table.columns[to] = {
+                    ...column,
+                    name: to
+                };
+            }
+        }
+        for (const [key, index] of Object.entries(table.indexes ?? {})){
+            const indexColumns = index.columns.map((column)=>{
+                const name = typeof column === 'string' ? column : column.expression;
+                const renamedName = columns.find(({ from })=>from === name)?.to ?? name;
+                return typeof column === 'string' ? renamedName : {
+                    ...column,
+                    expression: renamedName
+                };
+            });
+            const indexColumnNames = indexColumns.map((column)=>typeof column === 'string' ? column : column.expression);
+            const target = indexes.find((planned)=>planned.columns.join(',') === indexColumnNames.join(','));
+            if (!target) {
+                continue;
+            }
+            if (key !== target.to && table.indexes?.[target.to]) {
+                throw new Error(`Cannot create the sizes-to-variants migration because snapshot table "${tableName}" contains both indexes "${key}" and "${target.to}". Move or rename the existing destination index before creating this migration.`);
+            }
+            delete table.indexes[key];
+            table.indexes[target.to] = {
+                ...index,
+                name: target.to,
+                columns: indexColumns
+            };
+        }
+    }
+    renamed.prevId = snapshot.id;
+    renamed.id = randomUUID();
+    return renamed;
+}
+
+//# sourceMappingURL=buildDynamicPredefinedSizesToVariantsMigration.js.map

package/dist/utilities/buildDynamicPredefinedSizesToVariantsMigration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/buildDynamicPredefinedSizesToVariantsMigration.ts"],"sourcesContent":["import type { DynamicMigrationTemplate } from 'payload'\n\nimport { randomUUID } from 'crypto'\nimport { readdirSync, readFileSync, writeFileSync } from 'fs'\n\nimport type { DrizzleAdapter } from '../types.js'\nimport type { SizesToVariantsTableRenames } from './getSizesToVariantsRenames.js'\n\nimport {\n  findSizesToVariantsFieldCollision,\n  getSizesToVariantsRenames,\n} from './getSizesToVariantsRenames.js'\n\ntype SnapshotIndex = {\n  columns: ({ expression: string } | string)[]\n  name: string\n}\n\ntype SnapshotTable = {\n  columns: Record<string, { name: string }>\n  indexes?: Record<string, SnapshotIndex>\n  name: string\n}\n\ntype Snapshot = {\n  id?: string\n  prevId?: string\n  tables: Record<string, SnapshotTable>\n  version: string\n}\n\n/**\n * Builds the `sizes-to-variants` predefined migration for a SQL adapter. The migration renames\n * columns rather than letting drizzle-kit diff the schema (which would drop and re-add them,\n * losing every stored image size).\n *\n * It also writes a schema snapshot: the project's previous snapshot with only these renames\n * applied. The next generated migration then diffs from the renamed columns instead of dropping\n * them, and still picks up every other schema change the upgrade brings. Without a previous\n * snapshot (a project that has only ever used `push`) there's nothing to update, so none is written.\n */\nexport const buildDynamicPredefinedSizesToVariantsMigration = ({\n  packageName,\n}: {\n  packageName: string\n}): DynamicMigrationTemplate => {\n  return async ({ filePath, payload }) => {\n    const adapter = payload.db as unknown as DrizzleAdapter\n    const previousSnapshot = await readLatestSnapshot({ adapter })\n\n    if (previousSnapshot) {\n      const renamedSnapshot = applySizesToVariantsRenames({\n        plan: getSizesToVariantsRenames({ adapter, direction: 'up' }),\n        snapshot: previousSnapshot,\n      })\n\n      writeFileSync(`${filePath}.json`, JSON.stringify(renamedSnapshot, null, 2))\n    }\n\n    return {\n      downSQL: `  await migrateSizesToVariants({ db, direction: 'down', payload })`,\n      imports: `import { migrateSizesToVariants } from '${packageName}/migration-utils'`,\n      upSQL: `  await migrateSizesToVariants({ db, payload })`,\n    }\n  }\n}\n\n/** The latest snapshot in the migrations directory, upgraded to drizzle-kit's current format. */\nasync function readLatestSnapshot({\n  adapter,\n}: {\n  adapter: DrizzleAdapter\n}): Promise<Snapshot | undefined> {\n  const dir = adapter.migrationDir\n  const latestSnapshotFile = readdirSync(dir)\n    .filter((file) => file.endsWith('.json'))\n    .sort()\n    .reverse()[0]\n\n  if (!latestSnapshotFile) {\n    return undefined\n  }\n\n  const { generateDrizzleJson, upSnapshot } = adapter.requireDrizzleKit()\n  const currentVersion = (await generateDrizzleJson(adapter.schema)).version\n  const snapshot = JSON.parse(readFileSync(`${dir}/${latestSnapshotFile}`, 'utf8')) as Snapshot\n\n  return upSnapshot && snapshot.version < currentVersion ? upSnapshot(snapshot) : snapshot\n}\n\nfunction applySizesToVariantsRenames({\n  plan,\n  snapshot,\n}: {\n  plan: SizesToVariantsTableRenames[]\n  snapshot: Snapshot\n}): Snapshot {\n  const renamed: Snapshot = structuredClone(snapshot)\n\n  for (const { columns, indexes, tableName } of plan) {\n    const table = Object.values(renamed.tables).find(({ name }) => name === tableName)\n\n    if (!table) {\n      continue\n    }\n\n    const existingColumns = new Set(Object.values(table.columns).map(({ name }) => name))\n\n    for (const { from, to } of columns) {\n      if (existingColumns.has(from) && existingColumns.has(to)) {\n        throw new Error(\n          `Cannot create the sizes-to-variants migration because snapshot table \"${tableName}\" contains both \"${from}\" and \"${to}\". Move or rename the existing destination data before creating this migration.`,\n        )\n      }\n    }\n\n    const fieldCollision = findSizesToVariantsFieldCollision({ columns, existingColumns })\n\n    if (fieldCollision) {\n      throw new Error(\n        `Cannot create the sizes-to-variants migration because snapshot table \"${tableName}\" contains both the \"${fieldCollision.from}\" and \"${fieldCollision.to}\" fields. Move or rename the existing destination data before creating this migration.`,\n      )\n    }\n\n    for (const { from, to } of columns) {\n      const column = table.columns[from]\n\n      if (column) {\n        if (table.columns[to]) {\n          throw new Error(\n            `Cannot create the sizes-to-variants migration because snapshot table \"${tableName}\" contains both \"${from}\" and \"${to}\". Move or rename the existing destination data before creating this migration.`,\n          )\n        }\n\n        delete table.columns[from]\n        table.columns[to] = { ...column, name: to }\n      }\n    }\n\n    for (const [key, index] of Object.entries(table.indexes ?? {})) {\n      const indexColumns = index.columns.map((column) => {\n        const name = typeof column === 'string' ? column : column.expression\n        const renamedName = columns.find(({ from }) => from === name)?.to ?? name\n\n        return typeof column === 'string' ? renamedName : { ...column, expression: renamedName }\n      })\n      const indexColumnNames = indexColumns.map((column) =>\n        typeof column === 'string' ? column : column.expression,\n      )\n      const target = indexes.find(\n        (planned) => planned.columns.join(',') === indexColumnNames.join(','),\n      )\n\n      if (!target) {\n        continue\n      }\n\n      if (key !== target.to && table.indexes?.[target.to]) {\n        throw new Error(\n          `Cannot create the sizes-to-variants migration because snapshot table \"${tableName}\" contains both indexes \"${key}\" and \"${target.to}\". Move or rename the existing destination index before creating this migration.`,\n        )\n      }\n\n      delete table.indexes[key]\n      table.indexes[target.to] = { ...index, name: target.to, columns: indexColumns }\n    }\n  }\n\n  renamed.prevId = snapshot.id\n  renamed.id = randomUUID()\n\n  return renamed\n}\n"],"names":["randomUUID","readdirSync","readFileSync","writeFileSync","findSizesToVariantsFieldCollision","getSizesToVariantsRenames","buildDynamicPredefinedSizesToVariantsMigration","packageName","filePath","payload","adapter","db","previousSnapshot","readLatestSnapshot","renamedSnapshot","applySizesToVariantsRenames","plan","direction","snapshot","JSON","stringify","downSQL","imports","upSQL","dir","migrationDir","latestSnapshotFile","filter","file","endsWith","sort","reverse","undefined","generateDrizzleJson","upSnapshot","requireDrizzleKit","currentVersion","schema","version","parse","renamed","structuredClone","columns","indexes","tableName","table","Object","values","tables","find","name","existingColumns","Set","map","from","to","has","Error","fieldCollision","column","key","index","entries","indexColumns","expression","renamedName","indexColumnNames","target","planned","join","prevId","id"],"mappings":"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"}

package/dist/utilities/getSizesToVariantsRenames.d.ts

@@ -0,0 +1,54 @@
+import type { DrizzleAdapter } from '../types.js';
+export type SizesToVariantsDirection = 'down' | 'up';
+export type SizesToVariantsColumnRename = {
+    from: string;
+    to: string;
+};
+export type SizesToVariantsIndexRename = {
+    /** Columns the index covers, named as they are after the column renames. */
+    columns: string[];
+    /** The index name to rename from on `down`. The generated legacy name is resolved on `up`. */
+    from?: string;
+    /** Base used to verify a generated legacy index name, including a possible numeric suffix. */
+    legacyNameBase?: string;
+    to: string;
+    unique: boolean;
+};
+export type SizesToVariantsTableRenames = {
+    columns: SizesToVariantsColumnRename[];
+    indexes: SizesToVariantsIndexRename[];
+    tableName: string;
+};
+export declare function findSizesToVariantsFieldCollision({ columns, existingColumns, }: {
+    columns: SizesToVariantsColumnRename[];
+    existingColumns: Set<string>;
+}): {
+    from: string;
+    to: string;
+} | undefined;
+export declare function assertNoSizesToVariantsColumnCollisions({ columns, existingColumns, tableName, }: {
+    columns: SizesToVariantsColumnRename[];
+    existingColumns: Set<string>;
+    tableName: string;
+}): void;
+/**
+ * Plans the column and index renames that move every upload collection's stored image sizes
+ * between the legacy `sizes` group and `variants`. Reads the current (`variants`) schema the
+ * adapter built from the config, so it covers each collection's main and versions tables without
+ * re-deriving Payload's column naming.
+ *
+ * Index names come from the schema on `up`, and on `down` are rebuilt the way `buildIndexName`
+ * named them before the rename. The runner still has to locate the verified generated legacy name
+ * on `up`, since it may have a numeric suffix that keeps the name unique.
+ */
+export declare function getSizesToVariantsRenames({ adapter, direction, }: {
+    adapter: DrizzleAdapter;
+    direction: SizesToVariantsDirection;
+}): SizesToVariantsTableRenames[];
+/** Mirrors `buildIndexName` for an index that didn't collide, without registering the name. */
+export declare function isGeneratedLegacyIndexName({ indexName, legacyNameBase, }: {
+    indexName: string;
+    legacyNameBase: string;
+}): boolean;
+export declare function buildGeneratedLegacyIndexName(name: string, number?: number): string;
+//# sourceMappingURL=getSizesToVariantsRenames.d.ts.map

package/dist/utilities/getSizesToVariantsRenames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSizesToVariantsRenames.d.ts","sourceRoot":"","sources":["../../src/utilities/getSizesToVariantsRenames.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAsB,MAAM,aAAa,CAAA;AAIrE,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,IAAI,CAAA;AAEpD,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,4EAA4E;IAC5E,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,8FAA8F;IAC9F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,8FAA8F;IAC9F,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,2BAA2B,EAAE,CAAA;IACtC,OAAO,EAAE,0BAA0B,EAAE,CAAA;IACrC,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,wBAAgB,iCAAiC,CAAC,EAChD,OAAO,EACP,eAAe,GAChB,EAAE;IACD,OAAO,EAAE,2BAA2B,EAAE,CAAA;IACtC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAC7B,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA2B3C;AAED,wBAAgB,uCAAuC,CAAC,EACtD,OAAO,EACP,eAAe,EACf,SAAS,GACV,EAAE;IACD,OAAO,EAAE,2BAA2B,EAAE,CAAA;IACtC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,IAAI,CAgBP;AAiBD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,OAAO,EACP,SAAS,GACV,EAAE;IACD,OAAO,EAAE,cAAc,CAAA;IACvB,SAAS,EAAE,wBAAwB,CAAA;CACpC,GAAG,2BAA2B,EAAE,CAwEhC;AA6ID,+FAA+F;AAC/F,wBAAgB,0BAA0B,CAAC,EACzC,SAAS,EACT,cAAc,GACf,EAAE;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,MAAM,CAAA;CACvB,GAAG,OAAO,CAQV;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CAO9E"}