@sanity/cli 5.1.1-next.5 → 6.0.0-alpha.3

package/dist/actions/media/importMedia.js

@@ -0,0 +1,213 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import fs, { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { text } from 'node:stream/consumers';
+import { pipeline } from 'node:stream/promises';
+import { chalk } from '@sanity/cli-core/ux';
+import gunzipMaybe from 'gunzip-maybe';
+// @ts-expect-error `peek-stream` module currently untyped
+import isTar from 'is-tar';
+// @ts-expect-error `peek-stream` module currently untyped
+import peek from 'peek-stream';
+import { catchError, EMPTY, filter, from, map, mergeMap, mergeWith, of, switchMap, tap, zip } from 'rxjs';
+import tar from 'tar-fs';
+import { glob } from 'tinyglobby';
+import { findNdjsonEntry } from '../../util/findNdjsonEntry.js';
+import { importMediaDebug } from './importMediaDebug.js';
+const DEFAULT_CONCURRENCY = 6;
+export function importer(options) {
+    return resolveSource(options).pipe(mergeMap(({ aspectsNdjsonPath, files, images, workingPath })=>{
+        const fileCount = files.length + images.length;
+        if (fileCount === 0) {
+            throw new Error('No assets to import');
+        }
+        const context = {
+            ...options,
+            ndjson: ()=>createReadStream(aspectsNdjsonPath),
+            workingPath
+        };
+        return from(files).pipe(switchMap((file)=>zip(of('file'), of(file))), mergeWith(from(images).pipe(switchMap((file)=>zip(of('image'), of(file))))), fetchExistingAssets(context), uploadAsset(context), resolveAspectData(context), setAspects(context), map((asset)=>({
+                asset,
+                fileCount
+            })));
+    }));
+}
+/**
+ * @internal
+ */ export function resolveSource({ sourcePath }) {
+    return from(fs.stat(sourcePath)).pipe(switchMap((stats)=>{
+        return stats.isDirectory() ? of(sourcePath) : from(mkdtemp(path.join(tmpdir(), 'sanity-media-library-import'))).pipe(switchMap((tempPath)=>{
+            return from(pipeline(createReadStream(sourcePath), gunzipMaybe(), untarMaybe(tempPath))).pipe(map(()=>tempPath));
+        }));
+    }), switchMap((importSourcePath)=>{
+        return from(glob([
+            '**/data.ndjson'
+        ], {
+            absolute: true,
+            cwd: importSourcePath,
+            deep: 2
+        })).pipe(map(([aspectsNdjsonPath])=>({
+                aspectsNdjsonPath,
+                importSourcePath,
+                workingPath: aspectsNdjsonPath === undefined ? importSourcePath : path.dirname(aspectsNdjsonPath)
+            })));
+    }), tap(({ aspectsNdjsonPath, importSourcePath })=>{
+        if (aspectsNdjsonPath === undefined) {
+            throw new Error(`No ${chalk.bold('data.ndjson')} file found in import source ${chalk.bold(importSourcePath)}`);
+        }
+        importMediaDebug(`[Found NDJSON file] ${aspectsNdjsonPath}`);
+    }), switchMap(({ aspectsNdjsonPath, workingPath })=>{
+        return from(Promise.all([
+            glob([
+                'files/*'
+            ], {
+                cwd: workingPath
+            }),
+            glob([
+                'images/*'
+            ], {
+                cwd: workingPath
+            })
+        ])).pipe(map(([files, images])=>({
+                aspectsNdjsonPath,
+                files,
+                images,
+                workingPath
+            })));
+    }));
+}
+/**
+ * Untar the stream if its contents appear to be tarred.
+ *
+ * @internal
+ */ function untarMaybe(outputPath) {
+    // @ts-expect-error `peek-stream` module currently untyped
+    return peek({
+        maxBuffer: 300,
+        newline: false
+    }, (data, swap)=>{
+        if (isTar(data)) {
+            return swap(null, tar.extract(outputPath));
+        }
+        return swap(null);
+    });
+}
+/**
+ * Fetch the ids of all asset documents that reference the input asset.
+ * The input asset is identified by its SHA-1 hash.
+ *
+ * @internal
+ */ function fetchAssetsByHash({ client, type }) {
+    return switchMap((hash)=>client.observable.fetch(`*[
+          _type == "sanity.asset" &&
+          currentVersion._ref == *[
+            _type == $type &&
+            sha1hash == $hash
+          ][0]._id
+        ]._id`, {
+            hash,
+            type: [
+                'sanity',
+                `${type}Asset`
+            ].join('.')
+        }, {
+            tag: 'asset.getId'
+        }).pipe(switchMap((assetIds)=>zip(of(hash), of(assetIds)))));
+}
+function fetchExistingAssets({ client, workingPath }) {
+    return mergeMap(([type, asset])=>{
+        const createSha1Hash = createHash('sha1');
+        const sha1hash = text(createReadStream(path.join(workingPath, asset)).pipe(createSha1Hash).setEncoding('hex'));
+        return from(sha1hash).pipe(tap((hash)=>importMediaDebug(`[Asset ${asset}] Checking for ${type} asset with hash ${hash}`)), fetchAssetsByHash({
+            client,
+            type
+        }), map(([hash, assetIds])=>{
+            if (assetIds.length === 0) {
+                return [
+                    type,
+                    asset,
+                    hash
+                ];
+            }
+            return {
+                assetIds,
+                isExistingAsset: true,
+                originalFilename: asset,
+                sha1Hash: hash
+            };
+        }));
+    });
+}
+/**
+ * Find the first matching entry in the provided NDJSON stream and attach it to the asset object.
+ *
+ * @internal
+ */ function resolveAspectData({ ndjson }) {
+    return mergeMap((resolvedAsset)=>from(findNdjsonEntry(ndjson(), (line)=>typeof line === 'object' && line !== null && 'filename' in line && line.filename === resolvedAsset.originalFilename)).pipe(map((aspectsFromImport)=>({
+                ...resolvedAsset,
+                aspects: aspectsFromImport?.aspects
+            }))));
+}
+// TODO: Batch mutations to reduce HTTP request count.
+export function setAspects({ client, replaceAspects }) {
+    return mergeMap((asset)=>{
+        const { aspects, assetIds, isExistingAsset } = asset;
+        if (isExistingAsset && !replaceAspects) {
+            importMediaDebug(`[Asset ${asset.originalFilename}] Skipping replacement of existing aspects`);
+            return of(asset);
+        }
+        if (aspects === undefined) {
+            importMediaDebug(`[Asset ${asset.originalFilename}] No aspects to import`);
+            return of(asset);
+        }
+        const transaction = client.observable.transaction();
+        for (const assetId of assetIds){
+            transaction.patch(assetId, {
+                set: {
+                    aspects
+                }
+            });
+        }
+        importMediaDebug(`[Asset ${asset.originalFilename}] Setting aspects on asset documents ${JSON.stringify(assetIds)}`);
+        return transaction.commit({
+            tag: 'asset.setAspects',
+            visibility: 'async'
+        }).pipe(map(()=>asset));
+    }, DEFAULT_CONCURRENCY);
+}
+function uploadAsset({ client, workingPath }) {
+    return mergeMap((maybeResolvedAsset)=>{
+        if ('assetIds' in maybeResolvedAsset) {
+            importMediaDebug(`[Asset ${maybeResolvedAsset.originalFilename}] Skipping upload of existing asset with hash ${maybeResolvedAsset.sha1Hash}`);
+            return of(maybeResolvedAsset);
+        }
+        const [type, asset, hash] = maybeResolvedAsset;
+        importMediaDebug(`[Asset ${asset}] Uploading new asset`);
+        return client.observable.assets.upload(type, createReadStream(path.join(workingPath, asset)), {
+            tag: 'asset.upload'
+        }).pipe(catchError((error)=>{
+            // An asset matching the hash was not found during previous steps, but appears to exist upon upload.
+            //
+            // This may occur if:
+            //   - The asset was uploaded by another client since the check was performed.
+            //   - The asset instance document exists, but is not referenced by any asset document.
+            if (error.statusCode === 409) {
+                importMediaDebug(`[Asset ${asset}] Cannot overwrite existing ${type} asset with hash ${hash}`);
+                return EMPTY;
+            }
+            return EMPTY;
+        }), filter((response)=>response.type === 'response'), tap(()=>importMediaDebug(`[Asset ${asset}] Finished uploading new asset`)), // TODO: The `client.assets.upload` method should return `MediaLibraryUploadResponse` when operating on Media Library resources. When that occurs, this type assertion can be removed.
+        map((response)=>response.body), map((result)=>({
+                assetIds: [
+                    result.asset._id
+                ],
+                isExistingAsset: false,
+                originalFilename: asset,
+                sha1Hash: hash
+            })));
+    }, DEFAULT_CONCURRENCY);
+}
+
+//# sourceMappingURL=importMedia.js.map

package/dist/actions/media/importMedia.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/media/importMedia.ts"],"sourcesContent":["import {createHash} from 'node:crypto'\nimport {createReadStream, type ReadStream} from 'node:fs'\nimport fs, {mkdtemp} from 'node:fs/promises'\nimport {tmpdir} from 'node:os'\nimport path from 'node:path'\nimport {text} from 'node:stream/consumers'\nimport {pipeline} from 'node:stream/promises'\n\nimport {chalk, spinner} from '@sanity/cli-core/ux'\nimport {type SanityClient} from '@sanity/client'\nimport {type FileAsset, type ImageAsset, type SanityDocument} from '@sanity/types'\nimport gunzipMaybe from 'gunzip-maybe'\n// @ts-expect-error `peek-stream` module currently untyped\nimport isTar from 'is-tar'\n// @ts-expect-error `peek-stream` module currently untyped\nimport peek from 'peek-stream'\nimport {\n  catchError,\n  EMPTY,\n  filter,\n  from,\n  map,\n  mergeMap,\n  mergeWith,\n  type Observable,\n  of,\n  type OperatorFunction,\n  switchMap,\n  tap,\n  zip,\n} from 'rxjs'\nimport tar from 'tar-fs'\nimport {glob} from 'tinyglobby'\n\nimport {findNdjsonEntry} from '../../util/findNdjsonEntry.js'\nimport {importMediaDebug} from './importMediaDebug.js'\n\nconst DEFAULT_CONCURRENCY = 6\n\ninterface MediaLibraryUploadResult {\n  asset: SanityDocument & {\n    _type: 'sanity.asset'\n    aspects: unknown\n    assetType: FileAsset['_type'] | ImageAsset['_type']\n  }\n  assetInstance: FileAsset | ImageAsset\n}\n\ninterface MediaLibraryUploadResponse {\n  body: MediaLibraryUploadResult\n  type: 'response'\n}\n\nexport interface State {\n  /**\n   * The last asset processed.\n   */\n  asset: AssetWithAspects\n  /**\n   * The count of input files.\n   */\n  fileCount: number\n}\n\ninterface ResolvedAsset {\n  /**\n   * The ids of the `sanity.asset` documents that currently refer to the asset.\n   *\n   * These documents contain aspects, and reference an asset instance document.\n   */\n  assetIds: string[]\n  isExistingAsset: boolean\n  /**\n   * The original filename of the asset as it appears in the import source.\n   *\n   * Note: Currently includes `images/` or `files/` prefix.\n   */\n  originalFilename: string\n  sha1Hash: string\n}\n\nexport type AssetWithAspects<Asset extends ResolvedAsset = ResolvedAsset> = Asset & {\n  aspects: unknown | undefined\n}\n\ninterface Options {\n  client: SanityClient\n  replaceAspects: boolean\n  sourcePath: string\n  spinner: ReturnType<typeof spinner>\n}\n\ninterface Context extends Options {\n  ndjson: () => ReadStream\n  workingPath: string\n}\n\nexport function importer(options: Options): Observable<State> {\n  return resolveSource(options).pipe(\n    mergeMap(({aspectsNdjsonPath, files, images, workingPath}) => {\n      const fileCount = files.length + images.length\n\n      if (fileCount === 0) {\n        throw new Error('No assets to import')\n      }\n\n      const context: Context = {\n        ...options,\n        ndjson: () => createReadStream(aspectsNdjsonPath),\n        workingPath,\n      }\n\n      return from(files).pipe(\n        switchMap((file) => zip(of<'file'>('file'), of(file))),\n        mergeWith(from(images).pipe(switchMap((file) => zip(of<'image'>('image'), of(file))))),\n        fetchExistingAssets(context),\n        uploadAsset(context),\n        resolveAspectData(context),\n        setAspects(context),\n        map((asset) => ({\n          asset,\n          fileCount,\n        })),\n      )\n    }),\n  )\n}\n\n/**\n * @internal\n */\nexport function resolveSource({sourcePath}: Pick<Context, 'sourcePath'>): Observable<{\n  aspectsNdjsonPath: string\n  files: string[]\n  images: string[]\n  workingPath: string\n}> {\n  return from(fs.stat(sourcePath)).pipe(\n    switchMap((stats) => {\n      return stats.isDirectory()\n        ? of(sourcePath)\n        : from(mkdtemp(path.join(tmpdir(), 'sanity-media-library-import'))).pipe(\n            switchMap((tempPath) => {\n              return from(\n                pipeline(createReadStream(sourcePath), gunzipMaybe(), untarMaybe(tempPath)),\n              ).pipe(map(() => tempPath))\n            }),\n          )\n    }),\n    switchMap((importSourcePath) => {\n      return from(\n        glob(['**/data.ndjson'], {\n          absolute: true,\n          cwd: importSourcePath,\n          deep: 2,\n        }),\n      ).pipe(\n        map(([aspectsNdjsonPath]) => ({\n          aspectsNdjsonPath,\n          importSourcePath,\n          workingPath:\n            aspectsNdjsonPath === undefined ? importSourcePath : path.dirname(aspectsNdjsonPath),\n        })),\n      )\n    }),\n    tap(({aspectsNdjsonPath, importSourcePath}) => {\n      if (aspectsNdjsonPath === undefined) {\n        throw new Error(\n          `No ${chalk.bold('data.ndjson')} file found in import source ${chalk.bold(importSourcePath)}`,\n        )\n      }\n      importMediaDebug(`[Found NDJSON file] ${aspectsNdjsonPath}`)\n    }),\n    switchMap(({aspectsNdjsonPath, workingPath}) => {\n      return from(\n        Promise.all([\n          glob(['files/*'], {\n            cwd: workingPath,\n          }),\n          glob(['images/*'], {\n            cwd: workingPath,\n          }),\n        ]),\n      ).pipe(\n        map(([files, images]) => ({\n          aspectsNdjsonPath,\n          files,\n          images,\n          workingPath,\n        })),\n      )\n    }),\n  )\n}\n\n/**\n * Untar the stream if its contents appear to be tarred.\n *\n * @internal\n */\nfunction untarMaybe(outputPath: string) {\n  // @ts-expect-error `peek-stream` module currently untyped\n  return peek({maxBuffer: 300, newline: false}, (data, swap) => {\n    if (isTar(data)) {\n      return swap(null, tar.extract(outputPath))\n    }\n\n    return swap(null)\n  })\n}\n\n/**\n * Fetch the ids of all asset documents that reference the input asset.\n * The input asset is identified by its SHA-1 hash.\n *\n * @internal\n */\nfunction fetchAssetsByHash({\n  client,\n  type,\n}: {\n  client: SanityClient\n  type: 'file' | 'image'\n}): OperatorFunction<string, [hash: string, assetIds: string[]]> {\n  return switchMap((hash) =>\n    client.observable\n      .fetch<string[]>(\n        `*[\n          _type == \"sanity.asset\" &&\n          currentVersion._ref == *[\n            _type == $type &&\n            sha1hash == $hash\n          ][0]._id\n        ]._id`,\n        {\n          hash,\n          type: ['sanity', `${type}Asset`].join('.'),\n        },\n        {\n          tag: 'asset.getId',\n        },\n      )\n      .pipe(switchMap((assetIds) => zip(of(hash), of(assetIds)))),\n  )\n}\n\nfunction fetchExistingAssets({\n  client,\n  workingPath,\n}: Context): OperatorFunction<\n  [type: 'file' | 'image', asset: string],\n  [type: 'file' | 'image', asset: string, hash: string] | ResolvedAsset\n> {\n  return mergeMap(([type, asset]) => {\n    const createSha1Hash = createHash('sha1')\n\n    const sha1hash = text(\n      createReadStream(path.join(workingPath, asset)).pipe(createSha1Hash).setEncoding('hex'),\n    )\n\n    return from(sha1hash).pipe(\n      tap((hash) =>\n        importMediaDebug(`[Asset ${asset}] Checking for ${type} asset with hash ${hash}`),\n      ),\n      fetchAssetsByHash({client, type}),\n      map<\n        [string, string[]],\n        [type: 'file' | 'image', asset: string, hash: string] | ResolvedAsset\n      >(([hash, assetIds]) => {\n        if (assetIds.length === 0) {\n          return [type, asset, hash]\n        }\n\n        return {\n          assetIds,\n          isExistingAsset: true,\n          originalFilename: asset,\n          sha1Hash: hash,\n        }\n      }),\n    )\n  })\n}\n\n/**\n * Find the first matching entry in the provided NDJSON stream and attach it to the asset object.\n *\n * @internal\n */\nfunction resolveAspectData({ndjson}: Context): OperatorFunction<ResolvedAsset, AssetWithAspects> {\n  return mergeMap((resolvedAsset) =>\n    from(\n      findNdjsonEntry<{aspects: unknown}>(\n        ndjson(),\n        (line) =>\n          typeof line === 'object' &&\n          line !== null &&\n          'filename' in line &&\n          line.filename === resolvedAsset.originalFilename,\n      ),\n    ).pipe(\n      map((aspectsFromImport) => ({\n        ...resolvedAsset,\n        aspects: aspectsFromImport?.aspects,\n      })),\n    ),\n  )\n}\n\n// TODO: Batch mutations to reduce HTTP request count.\nexport function setAspects({\n  client,\n  replaceAspects,\n}: Pick<Context, 'client' | 'replaceAspects'>): OperatorFunction<\n  AssetWithAspects,\n  AssetWithAspects\n> {\n  return mergeMap((asset) => {\n    const {aspects, assetIds, isExistingAsset} = asset\n\n    if (isExistingAsset && !replaceAspects) {\n      importMediaDebug(`[Asset ${asset.originalFilename}] Skipping replacement of existing aspects`)\n      return of(asset)\n    }\n\n    if (aspects === undefined) {\n      importMediaDebug(`[Asset ${asset.originalFilename}] No aspects to import`)\n      return of(asset)\n    }\n\n    const transaction = client.observable.transaction()\n    for (const assetId of assetIds) {\n      transaction.patch(assetId, {set: {aspects}})\n    }\n\n    importMediaDebug(\n      `[Asset ${asset.originalFilename}] Setting aspects on asset documents ${JSON.stringify(assetIds)}`,\n    )\n\n    return transaction\n      .commit({\n        tag: 'asset.setAspects',\n        visibility: 'async',\n      })\n      .pipe(map(() => asset))\n  }, DEFAULT_CONCURRENCY)\n}\n\nfunction uploadAsset({\n  client,\n  workingPath,\n}: Context): OperatorFunction<\n  [type: 'file' | 'image', asset: string, hash: string] | ResolvedAsset,\n  ResolvedAsset\n> {\n  return mergeMap((maybeResolvedAsset) => {\n    if ('assetIds' in maybeResolvedAsset) {\n      importMediaDebug(\n        `[Asset ${maybeResolvedAsset.originalFilename}] Skipping upload of existing asset with hash ${maybeResolvedAsset.sha1Hash}`,\n      )\n      return of(maybeResolvedAsset)\n    }\n\n    const [type, asset, hash] = maybeResolvedAsset\n    importMediaDebug(`[Asset ${asset}] Uploading new asset`)\n\n    return client.observable.assets\n      .upload(type, createReadStream(path.join(workingPath, asset)), {\n        tag: 'asset.upload',\n      })\n      .pipe(\n        catchError((error) => {\n          // An asset matching the hash was not found during previous steps, but appears to exist upon upload.\n          //\n          // This may occur if:\n          //   - The asset was uploaded by another client since the check was performed.\n          //   - The asset instance document exists, but is not referenced by any asset document.\n          if (error.statusCode === 409) {\n            importMediaDebug(\n              `[Asset ${asset}] Cannot overwrite existing ${type} asset with hash ${hash}`,\n            )\n            return EMPTY\n          }\n          return EMPTY\n        }),\n        filter((response) => response.type === 'response'),\n        tap(() => importMediaDebug(`[Asset ${asset}] Finished uploading new asset`)),\n        // TODO: The `client.assets.upload` method should return `MediaLibraryUploadResponse` when operating on Media Library resources. When that occurs, this type assertion can be removed.\n        map((response) => (response as unknown as MediaLibraryUploadResponse).body),\n        map<MediaLibraryUploadResult, ResolvedAsset>((result) => ({\n          assetIds: [result.asset._id],\n          isExistingAsset: false,\n          originalFilename: asset,\n          sha1Hash: hash,\n        })),\n      )\n  }, DEFAULT_CONCURRENCY)\n}\n"],"names":["createHash","createReadStream","fs","mkdtemp","tmpdir","path","text","pipeline","chalk","gunzipMaybe","isTar","peek","catchError","EMPTY","filter","from","map","mergeMap","mergeWith","of","switchMap","tap","zip","tar","glob","findNdjsonEntry","importMediaDebug","DEFAULT_CONCURRENCY","importer","options","resolveSource","pipe","aspectsNdjsonPath","files","images","workingPath","fileCount","length","Error","context","ndjson","file","fetchExistingAssets","uploadAsset","resolveAspectData","setAspects","asset","sourcePath","stat","stats","isDirectory","join","tempPath","untarMaybe","importSourcePath","absolute","cwd","deep","undefined","dirname","bold","Promise","all","outputPath","maxBuffer","newline","data","swap","extract","fetchAssetsByHash","client","type","hash","observable","fetch","tag","assetIds","createSha1Hash","sha1hash","setEncoding","isExistingAsset","originalFilename","sha1Hash","resolvedAsset","line","filename","aspectsFromImport","aspects","replaceAspects","transaction","assetId","patch","set","JSON","stringify","commit","visibility","maybeResolvedAsset","assets","upload","error","statusCode","response","body","result","_id"],"mappings":"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"}

package/dist/actions/media/importMediaDebug.d.ts

@@ -0,0 +1 @@
+export declare const importMediaDebug: import("debug").Debugger;

package/dist/actions/media/importMediaDebug.js

@@ -0,0 +1,4 @@
+import { subdebug } from '@sanity/cli-core';
+export const importMediaDebug = subdebug('media:import');
+
+//# sourceMappingURL=importMediaDebug.js.map

package/dist/actions/media/importMediaDebug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/media/importMediaDebug.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\nexport const importMediaDebug = subdebug('media:import')\n"],"names":["subdebug","importMediaDebug"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,OAAO,MAAMC,mBAAmBD,SAAS,gBAAe"}

package/dist/actions/migration/getMigrationRootDirectory.d.ts

@@ -0,0 +1,2 @@
+import { Output } from '@sanity/cli-core';
+export declare function getMigrationRootDirectory(output: Output): Promise<string>;

package/dist/actions/migration/getMigrationRootDirectory.js

@@ -0,0 +1,14 @@
+import { findProjectRoot } from '@sanity/cli-core';
+export async function getMigrationRootDirectory(output) {
+    try {
+        const projectRoot = await findProjectRoot(process.cwd());
+        return projectRoot.directory;
+    } catch (error) {
+        const message = error instanceof Error ? error.message : 'Could not find Sanity project root';
+        output.error(message, {
+            exit: 1
+        });
+    }
+}
+
+//# sourceMappingURL=getMigrationRootDirectory.js.map

package/dist/actions/migration/getMigrationRootDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/getMigrationRootDirectory.ts"],"sourcesContent":["import {findProjectRoot, Output} from '@sanity/cli-core'\n\nexport async function getMigrationRootDirectory(output: Output): Promise<string> {\n  try {\n    const projectRoot = await findProjectRoot(process.cwd())\n    return projectRoot.directory\n  } catch (error) {\n    const message = error instanceof Error ? error.message : 'Could not find Sanity project root'\n    output.error(message, {exit: 1})\n  }\n}\n"],"names":["findProjectRoot","getMigrationRootDirectory","output","projectRoot","process","cwd","directory","error","message","Error","exit"],"mappings":"AAAA,SAAQA,eAAe,QAAe,mBAAkB;AAExD,OAAO,eAAeC,0BAA0BC,MAAc;IAC5D,IAAI;QACF,MAAMC,cAAc,MAAMH,gBAAgBI,QAAQC,GAAG;QACrD,OAAOF,YAAYG,SAAS;IAC9B,EAAE,OAAOC,OAAO;QACd,MAAMC,UAAUD,iBAAiBE,QAAQF,MAAMC,OAAO,GAAG;QACzDN,OAAOK,KAAK,CAACC,SAAS;YAACE,MAAM;QAAC;IAChC;AACF"}

package/dist/actions/migration/resolveMigrations.d.ts

@@ -0,0 +1,19 @@
+import { type Migration } from '@sanity/migrate';
+/**
+ * A resolved migration, where you are guaranteed that the migration file exists
+ *
+ * @internal
+ */
+interface ResolvedMigration {
+    id: string;
+    migration: Migration;
+}
+/**
+ * Resolves all migrations in the studio working directory
+ *
+ * @param workDir - The studio working directory
+ * @returns Array of migrations and their respective paths
+ * @internal
+ */
+export declare function resolveMigrations(workDir: string): Promise<ResolvedMigration[]>;
+export {};

package/dist/actions/migration/resolveMigrations.js

@@ -0,0 +1,43 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY } from '../../util/migration/constants.js';
+import { isLoadableMigrationScript, resolveMigrationScript } from '../../utils/migration/resolveMigrationScript.js';
+/**
+ * Removes migration script extensions from a filename
+ *
+ * @param fileName - The filename to process
+ * @returns The filename without the extension
+ * @internal
+ */ function removeMigrationScriptExtension(fileName) {
+    // Remove `.ts`, `.js` etc from the end of a filename
+    const ext = MIGRATION_SCRIPT_EXTENSIONS.find((e)=>fileName.endsWith(`.${e}`));
+    return ext ? path.basename(fileName, `.${ext}`) : fileName;
+}
+/**
+ * Resolves all migrations in the studio working directory
+ *
+ * @param workDir - The studio working directory
+ * @returns Array of migrations and their respective paths
+ * @internal
+ */ export async function resolveMigrations(workDir) {
+    const migrationsDir = path.join(workDir, MIGRATIONS_DIRECTORY);
+    const migrationEntries = await readdir(migrationsDir, {
+        withFileTypes: true
+    });
+    const migrations = [];
+    for (const entry of migrationEntries){
+        const entryName = entry.isDirectory() ? entry.name : removeMigrationScriptExtension(entry.name);
+        const candidates = await resolveMigrationScript(workDir, entryName);
+        for (const candidate of candidates){
+            if (isLoadableMigrationScript(candidate)) {
+                migrations.push({
+                    id: entryName,
+                    migration: candidate.mod.default
+                });
+            }
+        }
+    }
+    return migrations;
+}
+
+//# sourceMappingURL=resolveMigrations.js.map

package/dist/actions/migration/resolveMigrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/resolveMigrations.ts"],"sourcesContent":["import {readdir} from 'node:fs/promises'\nimport path from 'node:path'\n\nimport {type Migration} from '@sanity/migrate'\n\nimport {MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY} from '../../util/migration/constants.js'\nimport {\n  isLoadableMigrationScript,\n  resolveMigrationScript,\n} from '../../utils/migration/resolveMigrationScript.js'\n\n/**\n * A resolved migration, where you are guaranteed that the migration file exists\n *\n * @internal\n */\ninterface ResolvedMigration {\n  id: string\n  migration: Migration\n}\n\n/**\n * Removes migration script extensions from a filename\n *\n * @param fileName - The filename to process\n * @returns The filename without the extension\n * @internal\n */\nfunction removeMigrationScriptExtension(fileName: string): string {\n  // Remove `.ts`, `.js` etc from the end of a filename\n  const ext = MIGRATION_SCRIPT_EXTENSIONS.find((e) => fileName.endsWith(`.${e}`))\n  return ext ? path.basename(fileName, `.${ext}`) : fileName\n}\n\n/**\n * Resolves all migrations in the studio working directory\n *\n * @param workDir - The studio working directory\n * @returns Array of migrations and their respective paths\n * @internal\n */\nexport async function resolveMigrations(workDir: string): Promise<ResolvedMigration[]> {\n  const migrationsDir = path.join(workDir, MIGRATIONS_DIRECTORY)\n  const migrationEntries = await readdir(migrationsDir, {withFileTypes: true})\n\n  const migrations: ResolvedMigration[] = []\n  for (const entry of migrationEntries) {\n    const entryName = entry.isDirectory() ? entry.name : removeMigrationScriptExtension(entry.name)\n    const candidates = await resolveMigrationScript(workDir, entryName)\n    for (const candidate of candidates) {\n      if (isLoadableMigrationScript(candidate)) {\n        migrations.push({\n          id: entryName,\n          migration: candidate.mod.default,\n        })\n      }\n    }\n  }\n\n  return migrations\n}\n"],"names":["readdir","path","MIGRATION_SCRIPT_EXTENSIONS","MIGRATIONS_DIRECTORY","isLoadableMigrationScript","resolveMigrationScript","removeMigrationScriptExtension","fileName","ext","find","e","endsWith","basename","resolveMigrations","workDir","migrationsDir","join","migrationEntries","withFileTypes","migrations","entry","entryName","isDirectory","name","candidates","candidate","push","id","migration","mod","default"],"mappings":"AAAA,SAAQA,OAAO,QAAO,mBAAkB;AACxC,OAAOC,UAAU,YAAW;AAI5B,SAAQC,2BAA2B,EAAEC,oBAAoB,QAAO,oCAAmC;AACnG,SACEC,yBAAyB,EACzBC,sBAAsB,QACjB,kDAAiD;AAYxD;;;;;;CAMC,GACD,SAASC,+BAA+BC,QAAgB;IACtD,qDAAqD;IACrD,MAAMC,MAAMN,4BAA4BO,IAAI,CAAC,CAACC,IAAMH,SAASI,QAAQ,CAAC,CAAC,CAAC,EAAED,GAAG;IAC7E,OAAOF,MAAMP,KAAKW,QAAQ,CAACL,UAAU,CAAC,CAAC,EAAEC,KAAK,IAAID;AACpD;AAEA;;;;;;CAMC,GACD,OAAO,eAAeM,kBAAkBC,OAAe;IACrD,MAAMC,gBAAgBd,KAAKe,IAAI,CAACF,SAASX;IACzC,MAAMc,mBAAmB,MAAMjB,QAAQe,eAAe;QAACG,eAAe;IAAI;IAE1E,MAAMC,aAAkC,EAAE;IAC1C,KAAK,MAAMC,SAASH,iBAAkB;QACpC,MAAMI,YAAYD,MAAME,WAAW,KAAKF,MAAMG,IAAI,GAAGjB,+BAA+Bc,MAAMG,IAAI;QAC9F,MAAMC,aAAa,MAAMnB,uBAAuBS,SAASO;QACzD,KAAK,MAAMI,aAAaD,WAAY;YAClC,IAAIpB,0BAA0BqB,YAAY;gBACxCN,WAAWO,IAAI,CAAC;oBACdC,IAAIN;oBACJO,WAAWH,UAAUI,GAAG,CAACC,OAAO;gBAClC;YACF;QACF;IACF;IAEA,OAAOX;AACT"}

package/dist/actions/migration/templates/__tests__/minimalAdvanced.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, test } from 'vitest';
+import { minimalAdvanced } from '../minimalAdvanced';
+describe('#minimalAdvanced', ()=>{
+    test('creates template with no doc types', ()=>{
+        const minimalAdvancedTemplate = minimalAdvanced({
+            documentTypes: [],
+            migrationName: 'My Migration'
+        });
+        expect(minimalAdvancedTemplate).toMatchInlineSnapshot(`
+      "import {defineMigration, patch, at, setIfMissing} from '@sanity/migrate'
+
+      /**
+       * this migration will set \`Default title\` on all documents that are missing a title
+       * and make \`true\` the default value for the \`enabled\` field
+       */
+      export default defineMigration({
+        title: "My Migration",
+
+        async *migrate(documents, context) {
+          for await (const document of documents()) {
+            yield patch(document._id, [
+              at('title', setIfMissing('Default title')),
+              at('enabled', setIfMissing(true)),
+            ])
+          }
+        }
+      })
+      "
+    `);
+    });
+    test('creates template with doc types', ()=>{
+        const minimalAdvancedTemplate = minimalAdvanced({
+            documentTypes: [
+                'document-1',
+                'document-2',
+                'document-3'
+            ],
+            migrationName: 'My Migration'
+        });
+        expect(minimalAdvancedTemplate).toMatchInlineSnapshot(`
+      "import {defineMigration, patch, at, setIfMissing} from '@sanity/migrate'
+
+      /**
+       * this migration will set \`Default title\` on all documents that are missing a title
+       * and make \`true\` the default value for the \`enabled\` field
+       */
+      export default defineMigration({
+        title: "My Migration",
+        documentTypes: ["document-1", "document-2", "document-3"],
+
+        async *migrate(documents, context) {
+          for await (const document of documents()) {
+            yield patch(document._id, [
+              at('title', setIfMissing('Default title')),
+              at('enabled', setIfMissing(true)),
+            ])
+          }
+        }
+      })
+      "
+    `);
+    });
+});
+
+//# sourceMappingURL=minimalAdvanced.test.js.map

package/dist/actions/migration/templates/__tests__/minimalAdvanced.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/actions/migration/templates/__tests__/minimalAdvanced.test.ts"],"sourcesContent":["import {describe, expect, test} from 'vitest'\n\nimport {minimalAdvanced} from '../minimalAdvanced'\n\ndescribe('#minimalAdvanced', () => {\n  test('creates template with no doc types', () => {\n    const minimalAdvancedTemplate = minimalAdvanced({\n      documentTypes: [],\n      migrationName: 'My Migration',\n    })\n\n    expect(minimalAdvancedTemplate).toMatchInlineSnapshot(`\n      \"import {defineMigration, patch, at, setIfMissing} from '@sanity/migrate'\n\n      /**\n       * this migration will set \\`Default title\\` on all documents that are missing a title\n       * and make \\`true\\` the default value for the \\`enabled\\` field\n       */\n      export default defineMigration({\n        title: \"My Migration\",\n\n        async *migrate(documents, context) {\n          for await (const document of documents()) {\n            yield patch(document._id, [\n              at('title', setIfMissing('Default title')),\n              at('enabled', setIfMissing(true)),\n            ])\n          }\n        }\n      })\n      \"\n    `)\n  })\n\n  test('creates template with doc types', () => {\n    const minimalAdvancedTemplate = minimalAdvanced({\n      documentTypes: ['document-1', 'document-2', 'document-3'],\n      migrationName: 'My Migration',\n    })\n\n    expect(minimalAdvancedTemplate).toMatchInlineSnapshot(`\n      \"import {defineMigration, patch, at, setIfMissing} from '@sanity/migrate'\n\n      /**\n       * this migration will set \\`Default title\\` on all documents that are missing a title\n       * and make \\`true\\` the default value for the \\`enabled\\` field\n       */\n      export default defineMigration({\n        title: \"My Migration\",\n        documentTypes: [\"document-1\", \"document-2\", \"document-3\"],\n\n        async *migrate(documents, context) {\n          for await (const document of documents()) {\n            yield patch(document._id, [\n              at('title', setIfMissing('Default title')),\n              at('enabled', setIfMissing(true)),\n            ])\n          }\n        }\n      })\n      \"\n    `)\n  })\n})\n"],"names":["describe","expect","test","minimalAdvanced","minimalAdvancedTemplate","documentTypes","migrationName","toMatchInlineSnapshot"],"mappings":"AAAA,SAAQA,QAAQ,EAAEC,MAAM,EAAEC,IAAI,QAAO,SAAQ;AAE7C,SAAQC,eAAe,QAAO,qBAAoB;AAElDH,SAAS,oBAAoB;IAC3BE,KAAK,sCAAsC;QACzC,MAAME,0BAA0BD,gBAAgB;YAC9CE,eAAe,EAAE;YACjBC,eAAe;QACjB;QAEAL,OAAOG,yBAAyBG,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;IAoBvD,CAAC;IACH;IAEAL,KAAK,mCAAmC;QACtC,MAAME,0BAA0BD,gBAAgB;YAC9CE,eAAe;gBAAC;gBAAc;gBAAc;aAAa;YACzDC,eAAe;QACjB;QAEAL,OAAOG,yBAAyBG,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;IAqBvD,CAAC;IACH;AACF"}

package/dist/actions/migration/templates/__tests__/minimalSimple.test.js

@@ -0,0 +1,145 @@
+import { describe, expect, test } from 'vitest';
+import { minimalSimple } from '../minimalSimple';
+describe('#minimalSimple', ()=>{
+    test('creates template with no doc types', ()=>{
+        const minimalSimpleTemplate = minimalSimple({
+            documentTypes: [],
+            migrationName: 'My Migration'
+        });
+        expect(minimalSimpleTemplate).toMatchInlineSnapshot(`
+      "import {at, defineMigration, setIfMissing, unset} from '@sanity/migrate'
+
+      export default defineMigration({
+        title: "My Migration",
+
+        migrate: {
+          document(doc, context) {
+            // this will be called for every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+
+            return at('title', setIfMissing('Default title'))
+          },
+          node(node, path, context) {
+            // this will be called for every node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+
+            if (typeof node === 'string' && node === 'deleteme') {
+              return unset()
+            }
+          },
+          object(node, path, context) {
+            // this will be called for every object node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+            if (node._type === 'author') {
+              // make sure all authors objects have a books array
+              return at('books', setIfMissing([]))
+            }
+          },
+          array(node, path, context) {
+            // this will be called for every array node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          string(node, path, context) {
+            // this will be called for every string node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          number(node, path, context) {
+            // this will be called for every number node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          boolean(node, path, context) {
+            // this will be called for every boolean node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          null(node, path, context) {
+            // this will be called for every null node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+        },
+      })
+      "
+    `);
+    });
+    test('creates template with doc types', ()=>{
+        const minimalSimpleTemplate = minimalSimple({
+            documentTypes: [
+                'document-1',
+                'document-2',
+                'document-3'
+            ],
+            migrationName: 'My Migration'
+        });
+        expect(minimalSimpleTemplate).toMatchInlineSnapshot(`
+      "import {at, defineMigration, setIfMissing, unset} from '@sanity/migrate'
+
+      export default defineMigration({
+        title: "My Migration",
+        documentTypes: ["document-1", "document-2", "document-3"],
+
+        migrate: {
+          document(doc, context) {
+            // this will be called for every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+
+            return at('title', setIfMissing('Default title'))
+          },
+          node(node, path, context) {
+            // this will be called for every node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+
+            if (typeof node === 'string' && node === 'deleteme') {
+              return unset()
+            }
+          },
+          object(node, path, context) {
+            // this will be called for every object node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+            if (node._type === 'author') {
+              // make sure all authors objects have a books array
+              return at('books', setIfMissing([]))
+            }
+          },
+          array(node, path, context) {
+            // this will be called for every array node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          string(node, path, context) {
+            // this will be called for every string node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          number(node, path, context) {
+            // this will be called for every number node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          boolean(node, path, context) {
+            // this will be called for every boolean node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+          null(node, path, context) {
+            // this will be called for every null node in every document of the matching type
+            // any patch returned will be applied to the document
+            // you can also return mutations that touches other documents
+          },
+        },
+      })
+      "
+    `);
+    });
+});
+
+//# sourceMappingURL=minimalSimple.test.js.map

package/dist/actions/migration/templates/__tests__/minimalSimple.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/actions/migration/templates/__tests__/minimalSimple.test.ts"],"sourcesContent":["import {describe, expect, test} from 'vitest'\n\nimport {minimalSimple} from '../minimalSimple'\n\ndescribe('#minimalSimple', () => {\n  test('creates template with no doc types', () => {\n    const minimalSimpleTemplate = minimalSimple({\n      documentTypes: [],\n      migrationName: 'My Migration',\n    })\n\n    expect(minimalSimpleTemplate).toMatchInlineSnapshot(`\n      \"import {at, defineMigration, setIfMissing, unset} from '@sanity/migrate'\n\n      export default defineMigration({\n        title: \"My Migration\",\n\n        migrate: {\n          document(doc, context) {\n            // this will be called for every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n\n            return at('title', setIfMissing('Default title'))\n          },\n          node(node, path, context) {\n            // this will be called for every node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n\n            if (typeof node === 'string' && node === 'deleteme') {\n              return unset()\n            }\n          },\n          object(node, path, context) {\n            // this will be called for every object node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n            if (node._type === 'author') {\n              // make sure all authors objects have a books array\n              return at('books', setIfMissing([]))\n            }\n          },\n          array(node, path, context) {\n            // this will be called for every array node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          string(node, path, context) {\n            // this will be called for every string node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          number(node, path, context) {\n            // this will be called for every number node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          boolean(node, path, context) {\n            // this will be called for every boolean node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          null(node, path, context) {\n            // this will be called for every null node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n        },\n      })\n      \"\n    `)\n  })\n\n  test('creates template with doc types', () => {\n    const minimalSimpleTemplate = minimalSimple({\n      documentTypes: ['document-1', 'document-2', 'document-3'],\n      migrationName: 'My Migration',\n    })\n\n    expect(minimalSimpleTemplate).toMatchInlineSnapshot(`\n      \"import {at, defineMigration, setIfMissing, unset} from '@sanity/migrate'\n\n      export default defineMigration({\n        title: \"My Migration\",\n        documentTypes: [\"document-1\", \"document-2\", \"document-3\"],\n\n        migrate: {\n          document(doc, context) {\n            // this will be called for every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n\n            return at('title', setIfMissing('Default title'))\n          },\n          node(node, path, context) {\n            // this will be called for every node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n\n            if (typeof node === 'string' && node === 'deleteme') {\n              return unset()\n            }\n          },\n          object(node, path, context) {\n            // this will be called for every object node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n            if (node._type === 'author') {\n              // make sure all authors objects have a books array\n              return at('books', setIfMissing([]))\n            }\n          },\n          array(node, path, context) {\n            // this will be called for every array node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          string(node, path, context) {\n            // this will be called for every string node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          number(node, path, context) {\n            // this will be called for every number node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          boolean(node, path, context) {\n            // this will be called for every boolean node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n          null(node, path, context) {\n            // this will be called for every null node in every document of the matching type\n            // any patch returned will be applied to the document\n            // you can also return mutations that touches other documents\n          },\n        },\n      })\n      \"\n    `)\n  })\n})\n"],"names":["describe","expect","test","minimalSimple","minimalSimpleTemplate","documentTypes","migrationName","toMatchInlineSnapshot"],"mappings":"AAAA,SAAQA,QAAQ,EAAEC,MAAM,EAAEC,IAAI,QAAO,SAAQ;AAE7C,SAAQC,aAAa,QAAO,mBAAkB;AAE9CH,SAAS,kBAAkB;IACzBE,KAAK,sCAAsC;QACzC,MAAME,wBAAwBD,cAAc;YAC1CE,eAAe,EAAE;YACjBC,eAAe;QACjB;QAEAL,OAAOG,uBAAuBG,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4DrD,CAAC;IACH;IAEAL,KAAK,mCAAmC;QACtC,MAAME,wBAAwBD,cAAc;YAC1CE,eAAe;gBAAC;gBAAc;gBAAc;aAAa;YACzDC,eAAe;QACjB;QAEAL,OAAOG,uBAAuBG,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6DrD,CAAC;IACH;AACF"}