@sanity/cli 6.0.0-alpha.4 → 6.0.0-alpha.6

package/dist/actions/schema/deploySchemas.d.ts

@@ -0,0 +1,15 @@
+import { type Output } from '@sanity/cli-core';
+import { type SchemaStoreActionResult } from './schemaStoreTypes.js';
+interface DeploySchemasOptions {
+    extractManifest: boolean;
+    manifestDir: string;
+    output: Output;
+    verbose: boolean;
+    workDir: string;
+    manifestSafe?: boolean;
+    schemaRequired?: boolean;
+    tag?: string;
+    workspaceName?: string;
+}
+export declare function deploySchemas(options: DeploySchemasOptions): Promise<SchemaStoreActionResult>;
+export {};

package/dist/actions/schema/deploySchemas.js

@@ -0,0 +1,98 @@
+import { chalk } from '@sanity/cli-core/ux';
+import { updateSchemas } from '../../services/schemas.js';
+import { CURRENT_WORKSPACE_SCHEMA_VERSION } from '../manifest/types.js';
+import { schemasDeployDebug } from './utils/debug.js';
+import { ensureManifestExtractSatisfied } from './utils/manifestExtractor.js';
+import { createManifestReader } from './utils/manifestReader.js';
+import { FlagValidationError, SCHEMA_PERMISSION_HELP_TEXT } from './utils/schemaStoreValidation.js';
+import { getWorkspaceSchemaId } from './utils/workspaceSchemaId.js';
+export async function deploySchemas(options) {
+    const { extractManifest, manifestDir, manifestSafe, output, schemaRequired, tag, verbose, workDir, workspaceName } = options;
+    if (!await ensureManifestExtractSatisfied({
+        extractManifest,
+        manifestDir,
+        manifestSafe,
+        output,
+        schemaRequired,
+        workDir
+    })) {
+        return 'failure';
+    }
+    try {
+        const manifestReader = await createManifestReader({
+            manifestDir,
+            output,
+            workDir
+        });
+        const manifest = await manifestReader.getManifest();
+        const workspaces = manifest.workspaces.filter((workspace)=>!workspaceName || workspace.name === workspaceName);
+        if (workspaces.length === 0) {
+            const error = workspaceName ? new FlagValidationError(`Found no workspaces named "${workspaceName}"`) : new Error('Workspace array in manifest is empty.');
+            throw error;
+        }
+        const updateSchema = getUpdateSchema({
+            manifestReader,
+            output,
+            tag,
+            verbose
+        });
+        /* Known caveat: we _don't_ rollback failed operations or partial success */ const results = await Promise.allSettled(workspaces.map(async (workspace)=>{
+            await updateSchema(workspace);
+        }));
+        const fulfilledUpdates = results.filter((result)=>result.status === 'fulfilled');
+        const rejectedUpdates = results.filter((result)=>result.status === 'rejected');
+        if (rejectedUpdates.length > 0) {
+            throw new Error(`Failed to deploy ${rejectedUpdates.length}/${workspaces.length} schemas. Successfully deployed ${fulfilledUpdates.length}/${workspaces.length} schemas.`);
+        }
+        output.log(`Deployed ${fulfilledUpdates.length}/${workspaces.length} schemas`);
+        return 'success';
+    } catch (err) {
+        if (schemaRequired || err instanceof FlagValidationError) {
+            output.error(err.message);
+        } else {
+            output.error(`↳ Error when storing schemas:\n  ${err.message}`);
+        }
+        schemasDeployDebug('Error updating schemas', err.message);
+        return 'failure';
+    } finally{
+        output.log(`${chalk.gray('↳ List deployed schemas with:')} ${chalk.cyan('sanity schema list')}`);
+    }
+}
+function getUpdateSchema(args) {
+    const { manifestReader, output, tag, verbose } = args;
+    return async (workspace)=>{
+        const { dataset, projectId } = workspace;
+        const { idWarning, safeBaseId: id } = getWorkspaceSchemaId({
+            tag,
+            workspaceName: workspace.name
+        });
+        if (idWarning) output.warn(idWarning);
+        try {
+            const schema = await manifestReader.getWorkspaceSchema(workspace.name);
+            await updateSchemas(dataset, projectId, [
+                {
+                    // the API will stringify the schema – we send as JSON
+                    schema,
+                    tag,
+                    version: CURRENT_WORKSPACE_SCHEMA_VERSION,
+                    workspace: {
+                        name: workspace.name,
+                        title: workspace.title
+                    }
+                }
+            ]);
+            if (verbose) {
+                output.log(chalk.gray(`↳ schemaId: ${id}, projectId: ${projectId}, dataset: ${dataset}`));
+            }
+        } catch (err) {
+            if ('statusCode' in err && err?.statusCode === 401) {
+                output.warn(`↳ No permissions to write schema for workspace "${workspace.name}" in dataset "${workspace.dataset}". ${SCHEMA_PERMISSION_HELP_TEXT}:\n  ${chalk.red(`${err.message}`)}`);
+            } else {
+                output.error(`↳ Error deploying schema for workspace "${workspace.name}":\n  ${chalk.red(`${err.message}`)}`);
+            }
+            throw err;
+        }
+    };
+}
+
+//# sourceMappingURL=deploySchemas.js.map

package/dist/actions/schema/deploySchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/deploySchemas.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {type DeploySchemaCommand} from '../../commands/schema/deploy'\nimport {updateSchemas} from '../../services/schemas.js'\nimport {\n  CURRENT_WORKSPACE_SCHEMA_VERSION,\n  type ManifestWorkspaceFile,\n  type StoredWorkspaceSchema,\n} from '../manifest/types.js'\nimport {type SchemaStoreActionResult} from './schemaStoreTypes.js'\nimport {schemasDeployDebug} from './utils/debug.js'\nimport {ensureManifestExtractSatisfied} from './utils/manifestExtractor.js'\nimport {type CreateManifestReader, createManifestReader} from './utils/manifestReader.js'\nimport {FlagValidationError, SCHEMA_PERMISSION_HELP_TEXT} from './utils/schemaStoreValidation.js'\nimport {getWorkspaceSchemaId} from './utils/workspaceSchemaId.js'\n\ninterface DeploySchemasOptions {\n  extractManifest: boolean\n  manifestDir: string\n  output: Output\n  verbose: boolean\n  workDir: string\n\n  manifestSafe?: boolean\n  schemaRequired?: boolean\n  tag?: string\n  workspaceName?: string\n}\n\nexport async function deploySchemas(\n  options: DeploySchemasOptions,\n): Promise<SchemaStoreActionResult> {\n  const {\n    extractManifest,\n    manifestDir,\n    manifestSafe,\n    output,\n    schemaRequired,\n    tag,\n    verbose,\n    workDir,\n    workspaceName,\n  } = options\n\n  if (\n    !(await ensureManifestExtractSatisfied({\n      extractManifest,\n      manifestDir,\n      manifestSafe,\n      output,\n      schemaRequired,\n      workDir,\n    }))\n  ) {\n    return 'failure'\n  }\n\n  try {\n    const manifestReader = await createManifestReader({\n      manifestDir,\n      output,\n      workDir,\n    })\n    const manifest = await manifestReader.getManifest()\n    const workspaces = manifest.workspaces.filter(\n      (workspace) => !workspaceName || workspace.name === workspaceName,\n    )\n\n    if (workspaces.length === 0) {\n      const error = workspaceName\n        ? new FlagValidationError(`Found no workspaces named \"${workspaceName}\"`)\n        : new Error('Workspace array in manifest is empty.')\n      throw error\n    }\n\n    const updateSchema = getUpdateSchema({\n      manifestReader,\n      output,\n      tag,\n      verbose,\n    })\n\n    /* Known caveat: we _don't_ rollback failed operations or partial success */\n    const results = await Promise.allSettled(\n      workspaces.map(async (workspace: ManifestWorkspaceFile): Promise<void> => {\n        await updateSchema(workspace)\n      }),\n    )\n\n    const fulfilledUpdates = results.filter((result) => result.status === 'fulfilled')\n    const rejectedUpdates = results.filter((result) => result.status === 'rejected')\n\n    if (rejectedUpdates.length > 0) {\n      throw new Error(\n        `Failed to deploy ${rejectedUpdates.length}/${workspaces.length} schemas. Successfully deployed ${fulfilledUpdates.length}/${workspaces.length} schemas.`,\n      )\n    }\n\n    output.log(`Deployed ${fulfilledUpdates.length}/${workspaces.length} schemas`)\n    return 'success'\n  } catch (err) {\n    if (schemaRequired || err instanceof FlagValidationError) {\n      output.error(err.message)\n    } else {\n      output.error(`↳ Error when storing schemas:\\n  ${err.message}`)\n    }\n    schemasDeployDebug('Error updating schemas', err.message)\n    return 'failure'\n  } finally {\n    output.log(`${chalk.gray('↳ List deployed schemas with:')} ${chalk.cyan('sanity schema list')}`)\n  }\n}\n\nfunction getUpdateSchema(args: {\n  manifestReader: CreateManifestReader\n  output: DeploySchemaCommand['flags']['output']\n  tag?: string\n  verbose: boolean\n}): (workspace: ManifestWorkspaceFile) => Promise<void> {\n  const {manifestReader, output, tag, verbose} = args\n\n  return async (workspace) => {\n    const {dataset, projectId} = workspace\n\n    const {idWarning, safeBaseId: id} = getWorkspaceSchemaId({\n      tag,\n      workspaceName: workspace.name,\n    })\n\n    if (idWarning) output.warn(idWarning)\n\n    try {\n      const schema = await manifestReader.getWorkspaceSchema(workspace.name)\n\n      await updateSchemas<Omit<StoredWorkspaceSchema, '_id' | '_type'>[]>(dataset, projectId, [\n        {\n          // the API will stringify the schema – we send as JSON\n          schema,\n          tag,\n          version: CURRENT_WORKSPACE_SCHEMA_VERSION,\n          workspace: {\n            name: workspace.name,\n            title: workspace.title,\n          },\n        },\n      ])\n\n      if (verbose) {\n        output.log(chalk.gray(`↳ schemaId: ${id}, projectId: ${projectId}, dataset: ${dataset}`))\n      }\n    } catch (err) {\n      if ('statusCode' in err && err?.statusCode === 401) {\n        output.warn(\n          `↳ No permissions to write schema for workspace \"${workspace.name}\" in dataset \"${workspace.dataset}\". ${\n            SCHEMA_PERMISSION_HELP_TEXT\n          }:\\n  ${chalk.red(`${err.message}`)}`,\n        )\n      } else {\n        output.error(\n          `↳ Error deploying schema for workspace \"${workspace.name}\":\\n  ${chalk.red(`${err.message}`)}`,\n        )\n      }\n\n      throw err\n    }\n  }\n}\n"],"names":["chalk","updateSchemas","CURRENT_WORKSPACE_SCHEMA_VERSION","schemasDeployDebug","ensureManifestExtractSatisfied","createManifestReader","FlagValidationError","SCHEMA_PERMISSION_HELP_TEXT","getWorkspaceSchemaId","deploySchemas","options","extractManifest","manifestDir","manifestSafe","output","schemaRequired","tag","verbose","workDir","workspaceName","manifestReader","manifest","getManifest","workspaces","filter","workspace","name","length","error","Error","updateSchema","getUpdateSchema","results","Promise","allSettled","map","fulfilledUpdates","result","status","rejectedUpdates","log","err","message","gray","cyan","args","dataset","projectId","idWarning","safeBaseId","id","warn","schema","getWorkspaceSchema","version","title","statusCode","red"],"mappings":"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"}

package/dist/actions/schema/listSchemas.d.ts

@@ -0,0 +1,12 @@
+import { type Output } from '@sanity/cli-core';
+import { type SchemaStoreActionResult } from './schemaStoreTypes.js';
+interface ListSchemasOptions {
+    extractManifest: boolean;
+    json: boolean;
+    manifestDir: string;
+    output: Output;
+    workDir: string;
+    id?: string;
+}
+export declare function listSchemas(options: ListSchemasOptions): Promise<SchemaStoreActionResult>;
+export {};

package/dist/actions/schema/listSchemas.js

@@ -0,0 +1,119 @@
+import { chalk } from '@sanity/cli-core/ux';
+import { getSchemas } from '../../services/schemas.js';
+import { isDefined } from '../manifest/schemaTypeHelpers.js';
+import { schemasListDebug } from './utils/debug.js';
+import { ensureManifestExtractSatisfied } from './utils/manifestExtractor.js';
+import { createManifestReader } from './utils/manifestReader.js';
+import { getDatasetsOutString } from './utils/schemaStoreOutStrings.js';
+import { SCHEMA_PERMISSION_HELP_TEXT } from './utils/schemaStoreValidation.js';
+import { uniqByProjectIdDataset } from './utils/uniqByProjectIdDataset.js';
+class DatasetError extends Error {
+    dataset;
+    projectId;
+    constructor(args){
+        super(args.options?.cause?.message, args.options);
+        this.projectId = args.projectId;
+        this.dataset = args.dataset;
+        this.name = 'DatasetError';
+    }
+}
+export async function listSchemas(options) {
+    const { extractManifest, id, json, manifestDir, output, workDir } = options;
+    if (!await ensureManifestExtractSatisfied({
+        extractManifest,
+        manifestDir,
+        output,
+        schemaRequired: true,
+        workDir
+    })) {
+        return 'failure';
+    }
+    const manifest = await createManifestReader({
+        manifestDir,
+        output,
+        workDir
+    }).getManifest();
+    const projectDatasets = uniqByProjectIdDataset(manifest.workspaces);
+    const schemas = await getDatasetSchemas(projectDatasets, id);
+    const parsedSchemas = parseSchemas(schemas, output);
+    if (parsedSchemas.length === 0) {
+        const datasetString = getDatasetsOutString(projectDatasets.map((dataset)=>dataset.dataset));
+        output.error(id ? `Schema for id "${id}" not found in ${datasetString}` : `No schemas found in ${datasetString}`);
+        schemasListDebug('Error finding schema');
+        return 'failure';
+    }
+    if (json) {
+        output.log(`${JSON.stringify(id ? parsedSchemas[0] : parsedSchemas, null, 2)}`);
+    } else {
+        printSchemas({
+            manifest,
+            output,
+            schemas: parsedSchemas
+        });
+    }
+    return 'success';
+}
+async function getDatasetSchemas(projectDatasets, id) {
+    return await Promise.allSettled(projectDatasets.map(async ({ dataset, projectId })=>{
+        try {
+            return await getSchemas(dataset, projectId, id);
+        } catch (error) {
+            throw new DatasetError({
+                dataset,
+                options: {
+                    cause: error
+                },
+                projectId
+            });
+        }
+    }));
+}
+function parseSchemas(schemas, output) {
+    return schemas.map((schema)=>{
+        if (schema.status === 'fulfilled') return schema.value;
+        const error = schema.reason;
+        if (error instanceof DatasetError) {
+            if ('cause' in error && error.cause && typeof error.cause === 'object' && 'statusCode' in error.cause && error.cause.statusCode === 401) {
+                output.warn(`↳ No permissions to read schema from "${error.dataset}". ${SCHEMA_PERMISSION_HELP_TEXT}:\n  ${chalk.red(`${error.message}`)}`);
+                return [];
+            }
+            const message = chalk.red(`↳ Failed to fetch schema from "${error.dataset}":\n  ${error.message}`);
+            output.error(message);
+        } else {
+            //hubris inc: given the try-catch wrapping all the full promise "this should never happen"
+            throw error;
+        }
+    }).filter((schema)=>isDefined(schema)).flat();
+}
+function printSchemas({ manifest, output, schemas }) {
+    const rows = schemas.toSorted((a, b)=>-(a._createdAt || '').localeCompare(b._createdAt || '')).map(({ _createdAt: createdAt, _id: id, workspace })=>{
+        const workspaceData = manifest.workspaces.find((w)=>w.name === workspace.name);
+        if (!workspaceData) return;
+        return [
+            id,
+            workspace.name,
+            workspaceData.dataset,
+            workspaceData.projectId,
+            createdAt
+        ].map(String);
+    }).filter((schema)=>isDefined(schema));
+    const headings = [
+        'Id',
+        'Workspace',
+        'Dataset',
+        'ProjectId',
+        'CreatedAt'
+    ];
+    const maxWidths = headings.map((heading, i)=>{
+        const widths = [
+            ...rows.map((row)=>row[i].length),
+            heading.length
+        ];
+        return Math.max(...widths);
+    });
+    const rowToString = (row)=>row.map((col, i)=>`${col}`.padEnd(maxWidths[i])).join('   ');
+    output.log(chalk.cyan(rowToString(headings)));
+    for (const row of rows)output.log(rowToString(row));
+}
+
+//# sourceMappingURL=listSchemas.js.map

package/dist/actions/schema/listSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/listSchemas.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {type ListSchemaCommand} from '../../commands/schema/list.js'\nimport {getSchemas} from '../../services/schemas.js'\nimport {isDefined} from '../manifest/schemaTypeHelpers.js'\nimport {\n  type CreateManifest,\n  type ManifestWorkspaceFile,\n  type StoredWorkspaceSchema,\n} from '../manifest/types.js'\nimport {type SchemaStoreActionResult} from './schemaStoreTypes.js'\nimport {schemasListDebug} from './utils/debug.js'\nimport {ensureManifestExtractSatisfied} from './utils/manifestExtractor.js'\nimport {createManifestReader} from './utils/manifestReader.js'\nimport {getDatasetsOutString} from './utils/schemaStoreOutStrings.js'\nimport {SCHEMA_PERMISSION_HELP_TEXT} from './utils/schemaStoreValidation.js'\nimport {uniqByProjectIdDataset} from './utils/uniqByProjectIdDataset.js'\n\ninterface ListSchemasOptions {\n  extractManifest: boolean\n  json: boolean\n  manifestDir: string\n  output: Output\n  workDir: string\n\n  id?: string\n}\n\nclass DatasetError extends Error {\n  public dataset: string\n  public projectId: string\n  constructor(args: {dataset: string; options?: ErrorOptions; projectId: string}) {\n    super((args.options?.cause as {message?: string})?.message, args.options)\n    this.projectId = args.projectId\n    this.dataset = args.dataset\n    this.name = 'DatasetError'\n  }\n}\n\nexport async function listSchemas(options: ListSchemasOptions): Promise<SchemaStoreActionResult> {\n  const {extractManifest, id, json, manifestDir, output, workDir} = options\n\n  if (\n    !(await ensureManifestExtractSatisfied({\n      extractManifest,\n      manifestDir,\n      output,\n      schemaRequired: true,\n      workDir,\n    }))\n  ) {\n    return 'failure'\n  }\n\n  const manifest = await createManifestReader({\n    manifestDir,\n    output,\n    workDir,\n  }).getManifest()\n  const projectDatasets = uniqByProjectIdDataset(manifest.workspaces)\n  const schemas = (await getDatasetSchemas(projectDatasets, id)) as unknown as (\n    | PromiseFulfilledResult<StoredWorkspaceSchema>\n    | PromiseRejectedResult\n  )[]\n  const parsedSchemas = parseSchemas(schemas, output) as unknown as StoredWorkspaceSchema[]\n\n  if (parsedSchemas.length === 0) {\n    const datasetString = getDatasetsOutString(projectDatasets.map((dataset) => dataset.dataset))\n\n    output.error(\n      id\n        ? `Schema for id \"${id}\" not found in ${datasetString}`\n        : `No schemas found in ${datasetString}`,\n    )\n\n    schemasListDebug('Error finding schema')\n    return 'failure'\n  }\n\n  if (json) {\n    output.log(`${JSON.stringify(id ? parsedSchemas[0] : parsedSchemas, null, 2)}`)\n  } else {\n    printSchemas({manifest, output, schemas: parsedSchemas})\n  }\n\n  return 'success'\n}\n\nasync function getDatasetSchemas(\n  projectDatasets: ManifestWorkspaceFile[],\n  id?: ListSchemaCommand['flags']['id'],\n) {\n  return await Promise.allSettled(\n    projectDatasets.map(async ({dataset, projectId}) => {\n      try {\n        return await getSchemas(dataset, projectId, id)\n      } catch (error) {\n        throw new DatasetError({dataset, options: {cause: error}, projectId})\n      }\n    }),\n  )\n}\n\nfunction parseSchemas(\n  schemas: (PromiseFulfilledResult<StoredWorkspaceSchema> | PromiseRejectedResult)[],\n  output: Output,\n) {\n  return schemas\n    .map((schema) => {\n      if (schema.status === 'fulfilled') return schema.value\n\n      const error = schema.reason\n\n      if (error instanceof DatasetError) {\n        if (\n          'cause' in error &&\n          error.cause &&\n          typeof error.cause === 'object' &&\n          'statusCode' in error.cause &&\n          error.cause.statusCode === 401\n        ) {\n          output.warn(\n            `↳ No permissions to read schema from \"${error.dataset}\". ${\n              SCHEMA_PERMISSION_HELP_TEXT\n            }:\\n  ${chalk.red(`${error.message}`)}`,\n          )\n          return []\n        }\n\n        const message = chalk.red(\n          `↳ Failed to fetch schema from \"${error.dataset}\":\\n  ${error.message}`,\n        )\n        output.error(message)\n      } else {\n        //hubris inc: given the try-catch wrapping all the full promise \"this should never happen\"\n        throw error\n      }\n    })\n    .filter((schema) => isDefined(schema))\n    .flat()\n}\n\nfunction printSchemas({\n  manifest,\n  output,\n  schemas,\n}: {\n  manifest: CreateManifest\n  output: Output\n  schemas: StoredWorkspaceSchema[]\n}) {\n  const rows = schemas\n    .toSorted((a, b) => -(a._createdAt || '').localeCompare(b._createdAt || ''))\n    .map(({_createdAt: createdAt, _id: id, workspace}) => {\n      const workspaceData = manifest.workspaces.find((w) => w.name === workspace.name)\n\n      if (!workspaceData) return\n\n      return [id, workspace.name, workspaceData.dataset, workspaceData.projectId, createdAt].map(\n        String,\n      )\n    })\n    .filter((schema) => isDefined(schema))\n\n  const headings = ['Id', 'Workspace', 'Dataset', 'ProjectId', 'CreatedAt']\n\n  const maxWidths = headings.map((heading, i) => {\n    const widths = [...rows.map((row) => row[i].length), heading.length]\n    return Math.max(...widths)\n  })\n\n  const rowToString = (row: string[]) =>\n    row.map((col, i) => `${col}`.padEnd(maxWidths[i])).join('   ')\n\n  output.log(chalk.cyan(rowToString(headings)))\n  for (const row of rows) output.log(rowToString(row))\n}\n"],"names":["chalk","getSchemas","isDefined","schemasListDebug","ensureManifestExtractSatisfied","createManifestReader","getDatasetsOutString","SCHEMA_PERMISSION_HELP_TEXT","uniqByProjectIdDataset","DatasetError","Error","dataset","projectId","args","options","cause","message","name","listSchemas","extractManifest","id","json","manifestDir","output","workDir","schemaRequired","manifest","getManifest","projectDatasets","workspaces","schemas","getDatasetSchemas","parsedSchemas","parseSchemas","length","datasetString","map","error","log","JSON","stringify","printSchemas","Promise","allSettled","schema","status","value","reason","statusCode","warn","red","filter","flat","rows","toSorted","a","b","_createdAt","localeCompare","createdAt","_id","workspace","workspaceData","find","w","String","headings","maxWidths","heading","i","widths","row","Math","max","rowToString","col","padEnd","join","cyan"],"mappings":"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"}

package/dist/actions/schema/schemaStoreTypes.d.ts

@@ -1,14 +1,3 @@
-import { type Output } from '@sanity/cli-core';
-import { type SanityClient } from '@sanity/client';
-import { type ManifestExtractor } from './utils/manifestExtractor';
-import { type ManifestJsonReader } from './utils/manifestReader';
-export interface SchemaStoreContext {
-    apiClient: () => Promise<SanityClient>;
-    manifestExtractor: ManifestExtractor;
-    output: Output;
-    workDir: string;
-    jsonReader?: ManifestJsonReader;
-}
 /**
  * There is more context locally to decide how and when to log, depending on flags;
  * we therefore let actions log as soon as possible, possibly stopping stack unwinding.

package/dist/actions/schema/schemaStoreTypes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/actions/schema/schemaStoreTypes.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {type SanityClient} from '@sanity/client'\n\nimport {type ManifestExtractor} from './utils/manifestExtractor'\nimport {type ManifestJsonReader} from './utils/manifestReader'\n\nexport interface SchemaStoreContext {\n  apiClient: () => Promise<SanityClient>\n  manifestExtractor: ManifestExtractor\n  output: Output\n  workDir: string\n\n  jsonReader?: ManifestJsonReader\n}\n\n/**\n * There is more context locally to decide how and when to log, depending on flags;\n * we therefore let actions log as soon as possible, possibly stopping stack unwinding.\n * This gives us more control over the color and detail of the error message, as well as ensuring\n * we dont double-log errors up the chain.\n *\n * Depending on flags, store actions can fail without throwing; to allow control flow to continue,\n * even in the face of failure (--schema-required ture/false for store)\n *\n * It is up to action to make this distinction based on flags.\n *\n * However, we _do_ want to ensure correct exit code on commands (0 vs 1), so\n * CLI command chains are stopped if a store command fails.\n *\n * Invalid flags will always throw.\n *\n */\nexport type SchemaStoreActionResult = 'failure' | 'success'\n"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;CAgBC,GACD,WAA2D"}
+{"version":3,"sources":["../../../src/actions/schema/schemaStoreTypes.ts"],"sourcesContent":["/**\n * There is more context locally to decide how and when to log, depending on flags;\n * we therefore let actions log as soon as possible, possibly stopping stack unwinding.\n * This gives us more control over the color and detail of the error message, as well as ensuring\n * we dont double-log errors up the chain.\n *\n * Depending on flags, store actions can fail without throwing; to allow control flow to continue,\n * even in the face of failure (--schema-required ture/false for store)\n *\n * It is up to action to make this distinction based on flags.\n *\n * However, we _do_ want to ensure correct exit code on commands (0 vs 1), so\n * CLI command chains are stopped if a store command fails.\n *\n * Invalid flags will always throw.\n *\n */\nexport type SchemaStoreActionResult = 'failure' | 'success'\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GACD,WAA2D"}

package/dist/actions/schema/utils/debug.d.ts

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

package/dist/actions/schema/utils/debug.js

@@ -0,0 +1,5 @@
+import { subdebug } from '@sanity/cli-core';
+export const schemasDeployDebug = subdebug('schemas:deploy');
+export const schemasListDebug = subdebug('schemas:list');
+
+//# sourceMappingURL=debug.js.map

package/dist/actions/schema/utils/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/debug.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\nexport const schemasDeployDebug = subdebug('schemas:deploy')\nexport const schemasListDebug = subdebug('schemas:list')\n"],"names":["subdebug","schemasDeployDebug","schemasListDebug"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,OAAO,MAAMC,qBAAqBD,SAAS,kBAAiB;AAC5D,OAAO,MAAME,mBAAmBF,SAAS,gBAAe"}

package/dist/actions/schema/utils/manifestExtractor.d.ts

@@ -1,14 +1,9 @@
 import { type Output } from '@sanity/cli-core';
-export type ManifestExtractor = (manifestDir: string) => Promise<void>;
 export declare function ensureManifestExtractSatisfied(args: {
     extractManifest: boolean;
     manifestDir: string;
-    manifestExtractor: (manifestDir: string) => Promise<void>;
+    manifestSafe?: boolean;
     output: Output;
-    schemaRequired: boolean;
-}): Promise<boolean>;
-export declare function createManifestExtractor(context: {
-    output: Output;
-    safe?: boolean;
+    schemaRequired?: boolean;
     workDir: string;
-}): (manifestDir: string) => Promise<void>;
+}): Promise<boolean>;

package/dist/actions/schema/utils/manifestExtractor.js

@@ -2,13 +2,23 @@ import { chalk } from '@sanity/cli-core/ux';
 import { extractManifestSafe } from '../../manifest/extractManifest.js';
 import { FlagValidationError } from './schemaStoreValidation.js';
 export async function ensureManifestExtractSatisfied(args) {
-    const { extractManifest, manifestDir, manifestExtractor, output, schemaRequired } = args;
+    const { extractManifest, manifestDir, manifestSafe, output, schemaRequired, workDir } = args;
     if (!extractManifest) {
         return true;
     }
     try {
         // a successful manifest extract will write a new manifest file, which manifestReader will then read from disk
-        await manifestExtractor(manifestDir);
+        const error = await extractManifestSafe({
+            flags: {
+                json: false,
+                path: manifestDir
+            },
+            output,
+            workDir
+        });
+        if (!manifestSafe && error) {
+            throw error;
+        }
         return true;
     } catch (err) {
         if (schemaRequired || err instanceof FlagValidationError) {
@@ -19,20 +29,5 @@ export async function ensureManifestExtractSatisfied(args) {
         }
     }
 }
-export function createManifestExtractor(context) {
-    return async (manifestDir)=>{
-        const error = await extractManifestSafe({
-            flags: {
-                json: false,
-                path: manifestDir
-            },
-            output: context.output,
-            workDir: context.workDir
-        });
-        if (!context.safe && error) {
-            throw error;
-        }
-    };
-}
 
 //# sourceMappingURL=manifestExtractor.js.map

package/dist/actions/schema/utils/manifestExtractor.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/actions/schema/utils/manifestExtractor.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {extractManifestSafe} from '../../manifest/extractManifest.js'\nimport {FlagValidationError} from './schemaStoreValidation.js'\n\nexport type ManifestExtractor = (manifestDir: string) => Promise<void>\n\nexport async function ensureManifestExtractSatisfied(args: {\n  extractManifest: boolean\n  manifestDir: string\n  manifestExtractor: (manifestDir: string) => Promise<void>\n  output: Output\n  schemaRequired: boolean\n}) {\n  const {extractManifest, manifestDir, manifestExtractor, output, schemaRequired} = args\n  if (!extractManifest) {\n    return true\n  }\n  try {\n    // a successful manifest extract will write a new manifest file, which manifestReader will then read from disk\n    await manifestExtractor(manifestDir)\n    return true\n  } catch (err) {\n    if (schemaRequired || err instanceof FlagValidationError) {\n      throw err\n    } else {\n      output.log(chalk.gray(`↳ Failed to extract manifest:\\n  ${err.message}`))\n      return false\n    }\n  }\n}\n\nexport function createManifestExtractor(context: {\n  output: Output\n  safe?: boolean\n  workDir: string\n}) {\n  return async (manifestDir: string) => {\n    const error = await extractManifestSafe({\n      flags: {json: false, path: manifestDir},\n      output: context.output,\n      workDir: context.workDir,\n    })\n    if (!context.safe && error) {\n      throw error\n    }\n  }\n}\n"],"names":["chalk","extractManifestSafe","FlagValidationError","ensureManifestExtractSatisfied","args","extractManifest","manifestDir","manifestExtractor","output","schemaRequired","err","log","gray","message","createManifestExtractor","context","error","flags","json","path","workDir","safe"],"mappings":"AACA,SAAQA,KAAK,QAAO,sBAAqB;AAEzC,SAAQC,mBAAmB,QAAO,oCAAmC;AACrE,SAAQC,mBAAmB,QAAO,6BAA4B;AAI9D,OAAO,eAAeC,+BAA+BC,IAMpD;IACC,MAAM,EAACC,eAAe,EAAEC,WAAW,EAAEC,iBAAiB,EAAEC,MAAM,EAAEC,cAAc,EAAC,GAAGL;IAClF,IAAI,CAACC,iBAAiB;QACpB,OAAO;IACT;IACA,IAAI;QACF,8GAA8G;QAC9G,MAAME,kBAAkBD;QACxB,OAAO;IACT,EAAE,OAAOI,KAAK;QACZ,IAAID,kBAAkBC,eAAeR,qBAAqB;YACxD,MAAMQ;QACR,OAAO;YACLF,OAAOG,GAAG,CAACX,MAAMY,IAAI,CAAC,CAAC,iCAAiC,EAAEF,IAAIG,OAAO,EAAE;YACvE,OAAO;QACT;IACF;AACF;AAEA,OAAO,SAASC,wBAAwBC,OAIvC;IACC,OAAO,OAAOT;QACZ,MAAMU,QAAQ,MAAMf,oBAAoB;YACtCgB,OAAO;gBAACC,MAAM;gBAAOC,MAAMb;YAAW;YACtCE,QAAQO,QAAQP,MAAM;YACtBY,SAASL,QAAQK,OAAO;QAC1B;QACA,IAAI,CAACL,QAAQM,IAAI,IAAIL,OAAO;YAC1B,MAAMA;QACR;IACF;AACF"}
+{"version":3,"sources":["../../../../src/actions/schema/utils/manifestExtractor.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {extractManifestSafe} from '../../manifest/extractManifest.js'\nimport {FlagValidationError} from './schemaStoreValidation.js'\n\nexport async function ensureManifestExtractSatisfied(args: {\n  extractManifest: boolean\n  manifestDir: string\n  manifestSafe?: boolean\n  output: Output\n  schemaRequired?: boolean\n  workDir: string\n}) {\n  const {extractManifest, manifestDir, manifestSafe, output, schemaRequired, workDir} = args\n  if (!extractManifest) {\n    return true\n  }\n  try {\n    // a successful manifest extract will write a new manifest file, which manifestReader will then read from disk\n    const error = await extractManifestSafe({\n      flags: {json: false, path: manifestDir},\n      output,\n      workDir,\n    })\n\n    if (!manifestSafe && error) {\n      throw error\n    }\n\n    return true\n  } catch (err) {\n    if (schemaRequired || err instanceof FlagValidationError) {\n      throw err\n    } else {\n      output.log(chalk.gray(`↳ Failed to extract manifest:\\n  ${err.message}`))\n      return false\n    }\n  }\n}\n"],"names":["chalk","extractManifestSafe","FlagValidationError","ensureManifestExtractSatisfied","args","extractManifest","manifestDir","manifestSafe","output","schemaRequired","workDir","error","flags","json","path","err","log","gray","message"],"mappings":"AACA,SAAQA,KAAK,QAAO,sBAAqB;AAEzC,SAAQC,mBAAmB,QAAO,oCAAmC;AACrE,SAAQC,mBAAmB,QAAO,6BAA4B;AAE9D,OAAO,eAAeC,+BAA+BC,IAOpD;IACC,MAAM,EAACC,eAAe,EAAEC,WAAW,EAAEC,YAAY,EAAEC,MAAM,EAAEC,cAAc,EAAEC,OAAO,EAAC,GAAGN;IACtF,IAAI,CAACC,iBAAiB;QACpB,OAAO;IACT;IACA,IAAI;QACF,8GAA8G;QAC9G,MAAMM,QAAQ,MAAMV,oBAAoB;YACtCW,OAAO;gBAACC,MAAM;gBAAOC,MAAMR;YAAW;YACtCE;YACAE;QACF;QAEA,IAAI,CAACH,gBAAgBI,OAAO;YAC1B,MAAMA;QACR;QAEA,OAAO;IACT,EAAE,OAAOI,KAAK;QACZ,IAAIN,kBAAkBM,eAAeb,qBAAqB;YACxD,MAAMa;QACR,OAAO;YACLP,OAAOQ,GAAG,CAAChB,MAAMiB,IAAI,CAAC,CAAC,iCAAiC,EAAEF,IAAIG,OAAO,EAAE;YACvE,OAAO;QACT;IACF;AACF"}

package/dist/actions/schema/utils/manifestReader.d.ts

@@ -1,24 +1,17 @@
 import { type Output } from '@sanity/cli-core';
 import { type CreateManifest, type ManifestSchemaType } from '../../manifest/types.js';
-export type ManifestJsonReader = <T>(filePath: string) => Promise<JsonFileParseSuccess<T> | undefined>;
-export type CreateManifestReaderFactory = (args: {
-    jsonReader?: <T>(filePath: string) => Promise<JsonFileParseSuccess<T> | undefined>;
+type CreateManifestReaderFactory = (args: {
     manifestDir: string;
     output: Output;
+    workDir: string;
 }) => CreateManifestReader;
 export interface CreateManifestReader {
     getManifest: () => Promise<CreateManifest>;
     getWorkspaceSchema: (workspaceName: string) => Promise<ManifestSchemaType[]>;
 }
-interface JsonFileParseSuccess<T> {
-    lastModified: string;
-    parsedJson: T;
-    path: string;
-}
 /**
  * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.
  * If you need to re-read the manifest from disk, create a new instance.
  */
 export declare const createManifestReader: CreateManifestReaderFactory;
-export declare function resolveManifestDirectory(workDir: string, customPath?: string): string;
 export {};

package/dist/actions/schema/utils/manifestReader.js

@@ -5,17 +5,18 @@ import { MANIFEST_FILENAME } from '../../manifest/extractManifest.js';
 /**
  * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.
  * If you need to re-read the manifest from disk, create a new instance.
- */ export const createManifestReader = ({ jsonReader = parseJsonFile, manifestDir, output })=>{
+ */ export const createManifestReader = ({ manifestDir, output, workDir })=>{
     let parsedManifest;
     const parsedWorkspaces = {};
     const getManifest = async ()=>{
         if (parsedManifest) {
             return parsedManifest?.parsedJson;
         }
-        const manifestFile = path.join(manifestDir, MANIFEST_FILENAME);
-        const result = await jsonReader(manifestFile);
+        const staticPath = resolve(join(workDir, manifestDir));
+        const manifestFile = path.join(staticPath, MANIFEST_FILENAME);
+        const result = await parseJsonFile(manifestFile);
         if (!result) {
-            throw new Error(`Manifest does not exist at ${manifestFile}. To create the manifest file, omit --no-${'extract-manifest'} or run "sanity manifest extract" first.`);
+            throw new Error(`Manifest does not exist at ${manifestFile}. To create the manifest file, omit --no-extract-manifest or run "sanity manifest extract" first.`);
         }
         output.log(chalk.gray(`↳ Read manifest from ${manifestFile} (last modified: ${result.lastModified})`));
         parsedManifest = result;
@@ -34,7 +35,7 @@ import { MANIFEST_FILENAME } from '../../manifest/extractManifest.js';
             throw new Error(`No workspace named "${workspaceName}" found in manifest.`);
         }
         const workspaceSchemaFile = path.join(manifestDir, workspaceManifest.schema);
-        const result = await jsonReader(workspaceSchemaFile);
+        const result = await parseJsonFile(workspaceSchemaFile);
         if (!result) {
             throw new Error(`Workspace schema file at "${workspaceSchemaFile}" does not exist.`);
         }
@@ -46,13 +47,6 @@ import { MANIFEST_FILENAME } from '../../manifest/extractManifest.js';
         getWorkspaceSchema
     };
 };
-export function resolveManifestDirectory(workDir, customPath) {
-    const defaultOutputDir = resolve(join(workDir, 'dist'));
-    const outputDir = resolve(defaultOutputDir);
-    const defaultStaticPath = join(outputDir, 'static');
-    const staticPath = customPath ?? defaultStaticPath;
-    return path.resolve(process.cwd(), staticPath);
-}
 async function parseJsonFile(filePath) {
     let stats;
     try {

package/dist/actions/schema/utils/manifestReader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/actions/schema/utils/manifestReader.ts"],"sourcesContent":["import {type Stats} from 'node:fs'\nimport {readFile, stat} from 'node:fs/promises'\nimport path, {join, resolve} from 'node:path'\n\nimport {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {MANIFEST_FILENAME} from '../../manifest/extractManifest.js'\nimport {type CreateManifest, type ManifestSchemaType} from '../../manifest/types.js'\nimport {type DeploySchemasFlags} from './schemaStoreValidation.js'\n\nexport type ManifestJsonReader = <T>(\n  filePath: string,\n) => Promise<JsonFileParseSuccess<T> | undefined>\n\nexport type CreateManifestReaderFactory = (args: {\n  jsonReader?: <T>(filePath: string) => Promise<JsonFileParseSuccess<T> | undefined>\n  manifestDir: string\n  output: Output\n}) => CreateManifestReader\n\nexport interface CreateManifestReader {\n  getManifest: () => Promise<CreateManifest>\n  getWorkspaceSchema: (workspaceName: string) => Promise<ManifestSchemaType[]>\n}\n\ninterface JsonFileParseSuccess<T> {\n  lastModified: string\n  parsedJson: T\n  path: string\n}\n\n/**\n * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.\n * If you need to re-read the manifest from disk, create a new instance.\n */\nexport const createManifestReader: CreateManifestReaderFactory = ({\n  jsonReader = parseJsonFile,\n  manifestDir,\n  output,\n}) => {\n  let parsedManifest: JsonFileParseSuccess<CreateManifest>\n  const parsedWorkspaces: Record<string, JsonFileParseSuccess<ManifestSchemaType[]> | undefined> =\n    {}\n\n  const getManifest: CreateManifestReader['getManifest'] = async () => {\n    if (parsedManifest) {\n      return parsedManifest?.parsedJson\n    }\n\n    const manifestFile = path.join(manifestDir, MANIFEST_FILENAME)\n\n    const result = await jsonReader<CreateManifest>(manifestFile)\n    if (!result) {\n      throw new Error(\n        `Manifest does not exist at ${manifestFile}. To create the manifest file, omit --no-${'extract-manifest' satisfies keyof DeploySchemasFlags} or run \"sanity manifest extract\" first.`,\n      )\n    }\n\n    output.log(\n      chalk.gray(`↳ Read manifest from ${manifestFile} (last modified: ${result.lastModified})`),\n    )\n\n    parsedManifest = result\n    return result.parsedJson\n  }\n\n  const getWorkspaceSchema: CreateManifestReader['getWorkspaceSchema'] = async (workspaceName) => {\n    if (parsedWorkspaces[workspaceName]) {\n      return parsedWorkspaces[workspaceName]?.parsedJson\n    }\n    const manifest = await getManifest()\n    if (!manifest) {\n      throw new Error('Manifest is required to read workspace schema.')\n    }\n\n    const workspaceManifest = manifest.workspaces.find(\n      (workspace) => workspace.name === workspaceName,\n    )\n\n    if (!workspaceManifest) {\n      throw new Error(`No workspace named \"${workspaceName}\" found in manifest.`)\n    }\n\n    const workspaceSchemaFile = path.join(manifestDir, workspaceManifest.schema)\n    const result = await jsonReader<ManifestSchemaType[]>(workspaceSchemaFile)\n    if (!result) {\n      throw new Error(`Workspace schema file at \"${workspaceSchemaFile}\" does not exist.`)\n    }\n    parsedWorkspaces[workspaceName] = result\n    return result.parsedJson\n  }\n  return {\n    getManifest,\n    getWorkspaceSchema,\n  }\n}\n\nexport function resolveManifestDirectory(workDir: string, customPath?: string): string {\n  const defaultOutputDir = resolve(join(workDir, 'dist'))\n\n  const outputDir = resolve(defaultOutputDir)\n  const defaultStaticPath = join(outputDir, 'static')\n\n  const staticPath = customPath ?? defaultStaticPath\n  return path.resolve(process.cwd(), staticPath)\n}\n\nasync function parseJsonFile<T>(filePath: string): Promise<JsonFileParseSuccess<T> | undefined> {\n  let stats: Stats\n  try {\n    stats = await stat(filePath)\n  } catch {\n    // file does not exist\n    return undefined\n  }\n  const content = await readFile(filePath, 'utf8')\n  const lastModified = stats.mtime.toISOString()\n  const json = JSON.parse(content) as T\n  if (!json) {\n    throw new Error(`JSON file \"${filePath}\" was empty.`)\n  }\n  return {\n    lastModified,\n    parsedJson: json,\n    path: filePath,\n  }\n}\n"],"names":["readFile","stat","path","join","resolve","chalk","MANIFEST_FILENAME","createManifestReader","jsonReader","parseJsonFile","manifestDir","output","parsedManifest","parsedWorkspaces","getManifest","parsedJson","manifestFile","result","Error","log","gray","lastModified","getWorkspaceSchema","workspaceName","manifest","workspaceManifest","workspaces","find","workspace","name","workspaceSchemaFile","schema","resolveManifestDirectory","workDir","customPath","defaultOutputDir","outputDir","defaultStaticPath","staticPath","process","cwd","filePath","stats","undefined","content","mtime","toISOString","json","JSON","parse"],"mappings":"AACA,SAAQA,QAAQ,EAAEC,IAAI,QAAO,mBAAkB;AAC/C,OAAOC,QAAOC,IAAI,EAAEC,OAAO,QAAO,YAAW;AAG7C,SAAQC,KAAK,QAAO,sBAAqB;AAEzC,SAAQC,iBAAiB,QAAO,oCAAmC;AAyBnE;;;CAGC,GACD,OAAO,MAAMC,uBAAoD,CAAC,EAChEC,aAAaC,aAAa,EAC1BC,WAAW,EACXC,MAAM,EACP;IACC,IAAIC;IACJ,MAAMC,mBACJ,CAAC;IAEH,MAAMC,cAAmD;QACvD,IAAIF,gBAAgB;YAClB,OAAOA,gBAAgBG;QACzB;QAEA,MAAMC,eAAed,KAAKC,IAAI,CAACO,aAAaJ;QAE5C,MAAMW,SAAS,MAAMT,WAA2BQ;QAChD,IAAI,CAACC,QAAQ;YACX,MAAM,IAAIC,MACR,CAAC,2BAA2B,EAAEF,aAAa,yCAAyC,EAAE,mBAAsD,wCAAwC,CAAC;QAEzL;QAEAL,OAAOQ,GAAG,CACRd,MAAMe,IAAI,CAAC,CAAC,qBAAqB,EAAEJ,aAAa,iBAAiB,EAAEC,OAAOI,YAAY,CAAC,CAAC,CAAC;QAG3FT,iBAAiBK;QACjB,OAAOA,OAAOF,UAAU;IAC1B;IAEA,MAAMO,qBAAiE,OAAOC;QAC5E,IAAIV,gBAAgB,CAACU,cAAc,EAAE;YACnC,OAAOV,gBAAgB,CAACU,cAAc,EAAER;QAC1C;QACA,MAAMS,WAAW,MAAMV;QACvB,IAAI,CAACU,UAAU;YACb,MAAM,IAAIN,MAAM;QAClB;QAEA,MAAMO,oBAAoBD,SAASE,UAAU,CAACC,IAAI,CAChD,CAACC,YAAcA,UAAUC,IAAI,KAAKN;QAGpC,IAAI,CAACE,mBAAmB;YACtB,MAAM,IAAIP,MAAM,CAAC,oBAAoB,EAAEK,cAAc,oBAAoB,CAAC;QAC5E;QAEA,MAAMO,sBAAsB5B,KAAKC,IAAI,CAACO,aAAae,kBAAkBM,MAAM;QAC3E,MAAMd,SAAS,MAAMT,WAAiCsB;QACtD,IAAI,CAACb,QAAQ;YACX,MAAM,IAAIC,MAAM,CAAC,0BAA0B,EAAEY,oBAAoB,iBAAiB,CAAC;QACrF;QACAjB,gBAAgB,CAACU,cAAc,GAAGN;QAClC,OAAOA,OAAOF,UAAU;IAC1B;IACA,OAAO;QACLD;QACAQ;IACF;AACF,EAAC;AAED,OAAO,SAASU,yBAAyBC,OAAe,EAAEC,UAAmB;IAC3E,MAAMC,mBAAmB/B,QAAQD,KAAK8B,SAAS;IAE/C,MAAMG,YAAYhC,QAAQ+B;IAC1B,MAAME,oBAAoBlC,KAAKiC,WAAW;IAE1C,MAAME,aAAaJ,cAAcG;IACjC,OAAOnC,KAAKE,OAAO,CAACmC,QAAQC,GAAG,IAAIF;AACrC;AAEA,eAAe7B,cAAiBgC,QAAgB;IAC9C,IAAIC;IACJ,IAAI;QACFA,QAAQ,MAAMzC,KAAKwC;IACrB,EAAE,OAAM;QACN,sBAAsB;QACtB,OAAOE;IACT;IACA,MAAMC,UAAU,MAAM5C,SAASyC,UAAU;IACzC,MAAMpB,eAAeqB,MAAMG,KAAK,CAACC,WAAW;IAC5C,MAAMC,OAAOC,KAAKC,KAAK,CAACL;IACxB,IAAI,CAACG,MAAM;QACT,MAAM,IAAI7B,MAAM,CAAC,WAAW,EAAEuB,SAAS,YAAY,CAAC;IACtD;IACA,OAAO;QACLpB;QACAN,YAAYgC;QACZ7C,MAAMuC;IACR;AACF"}
+{"version":3,"sources":["../../../../src/actions/schema/utils/manifestReader.ts"],"sourcesContent":["import {type Stats} from 'node:fs'\nimport {readFile, stat} from 'node:fs/promises'\nimport path, {join, resolve} from 'node:path'\n\nimport {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {MANIFEST_FILENAME} from '../../manifest/extractManifest.js'\nimport {type CreateManifest, type ManifestSchemaType} from '../../manifest/types.js'\n\ntype CreateManifestReaderFactory = (args: {\n  manifestDir: string\n  output: Output\n  workDir: string\n}) => CreateManifestReader\n\nexport interface CreateManifestReader {\n  getManifest: () => Promise<CreateManifest>\n  getWorkspaceSchema: (workspaceName: string) => Promise<ManifestSchemaType[]>\n}\n\ninterface JsonFileParseSuccess<T> {\n  lastModified: string\n  parsedJson: T\n  path: string\n}\n\n/**\n * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.\n * If you need to re-read the manifest from disk, create a new instance.\n */\nexport const createManifestReader: CreateManifestReaderFactory = ({\n  manifestDir,\n  output,\n  workDir,\n}) => {\n  let parsedManifest: JsonFileParseSuccess<CreateManifest>\n  const parsedWorkspaces: Record<string, JsonFileParseSuccess<ManifestSchemaType[]> | undefined> =\n    {}\n\n  const getManifest: CreateManifestReader['getManifest'] = async () => {\n    if (parsedManifest) {\n      return parsedManifest?.parsedJson\n    }\n\n    const staticPath = resolve(join(workDir, manifestDir))\n    const manifestFile = path.join(staticPath, MANIFEST_FILENAME)\n\n    const result = await parseJsonFile<CreateManifest>(manifestFile)\n    if (!result) {\n      throw new Error(\n        `Manifest does not exist at ${manifestFile}. To create the manifest file, omit --no-extract-manifest or run \"sanity manifest extract\" first.`,\n      )\n    }\n\n    output.log(\n      chalk.gray(`↳ Read manifest from ${manifestFile} (last modified: ${result.lastModified})`),\n    )\n\n    parsedManifest = result\n    return result.parsedJson\n  }\n\n  const getWorkspaceSchema: CreateManifestReader['getWorkspaceSchema'] = async (workspaceName) => {\n    if (parsedWorkspaces[workspaceName]) {\n      return parsedWorkspaces[workspaceName]?.parsedJson\n    }\n    const manifest = await getManifest()\n    if (!manifest) {\n      throw new Error('Manifest is required to read workspace schema.')\n    }\n\n    const workspaceManifest = manifest.workspaces.find(\n      (workspace) => workspace.name === workspaceName,\n    )\n\n    if (!workspaceManifest) {\n      throw new Error(`No workspace named \"${workspaceName}\" found in manifest.`)\n    }\n\n    const workspaceSchemaFile = path.join(manifestDir, workspaceManifest.schema)\n    const result = await parseJsonFile<ManifestSchemaType[]>(workspaceSchemaFile)\n    if (!result) {\n      throw new Error(`Workspace schema file at \"${workspaceSchemaFile}\" does not exist.`)\n    }\n    parsedWorkspaces[workspaceName] = result\n    return result.parsedJson\n  }\n  return {\n    getManifest,\n    getWorkspaceSchema,\n  }\n}\n\nasync function parseJsonFile<T>(filePath: string): Promise<JsonFileParseSuccess<T> | undefined> {\n  let stats: Stats\n  try {\n    stats = await stat(filePath)\n  } catch {\n    // file does not exist\n    return undefined\n  }\n  const content = await readFile(filePath, 'utf8')\n  const lastModified = stats.mtime.toISOString()\n  const json = JSON.parse(content) as T\n  if (!json) {\n    throw new Error(`JSON file \"${filePath}\" was empty.`)\n  }\n  return {\n    lastModified,\n    parsedJson: json,\n    path: filePath,\n  }\n}\n"],"names":["readFile","stat","path","join","resolve","chalk","MANIFEST_FILENAME","createManifestReader","manifestDir","output","workDir","parsedManifest","parsedWorkspaces","getManifest","parsedJson","staticPath","manifestFile","result","parseJsonFile","Error","log","gray","lastModified","getWorkspaceSchema","workspaceName","manifest","workspaceManifest","workspaces","find","workspace","name","workspaceSchemaFile","schema","filePath","stats","undefined","content","mtime","toISOString","json","JSON","parse"],"mappings":"AACA,SAAQA,QAAQ,EAAEC,IAAI,QAAO,mBAAkB;AAC/C,OAAOC,QAAOC,IAAI,EAAEC,OAAO,QAAO,YAAW;AAG7C,SAAQC,KAAK,QAAO,sBAAqB;AAEzC,SAAQC,iBAAiB,QAAO,oCAAmC;AAoBnE;;;CAGC,GACD,OAAO,MAAMC,uBAAoD,CAAC,EAChEC,WAAW,EACXC,MAAM,EACNC,OAAO,EACR;IACC,IAAIC;IACJ,MAAMC,mBACJ,CAAC;IAEH,MAAMC,cAAmD;QACvD,IAAIF,gBAAgB;YAClB,OAAOA,gBAAgBG;QACzB;QAEA,MAAMC,aAAaX,QAAQD,KAAKO,SAASF;QACzC,MAAMQ,eAAed,KAAKC,IAAI,CAACY,YAAYT;QAE3C,MAAMW,SAAS,MAAMC,cAA8BF;QACnD,IAAI,CAACC,QAAQ;YACX,MAAM,IAAIE,MACR,CAAC,2BAA2B,EAAEH,aAAa,iGAAiG,CAAC;QAEjJ;QAEAP,OAAOW,GAAG,CACRf,MAAMgB,IAAI,CAAC,CAAC,qBAAqB,EAAEL,aAAa,iBAAiB,EAAEC,OAAOK,YAAY,CAAC,CAAC,CAAC;QAG3FX,iBAAiBM;QACjB,OAAOA,OAAOH,UAAU;IAC1B;IAEA,MAAMS,qBAAiE,OAAOC;QAC5E,IAAIZ,gBAAgB,CAACY,cAAc,EAAE;YACnC,OAAOZ,gBAAgB,CAACY,cAAc,EAAEV;QAC1C;QACA,MAAMW,WAAW,MAAMZ;QACvB,IAAI,CAACY,UAAU;YACb,MAAM,IAAIN,MAAM;QAClB;QAEA,MAAMO,oBAAoBD,SAASE,UAAU,CAACC,IAAI,CAChD,CAACC,YAAcA,UAAUC,IAAI,KAAKN;QAGpC,IAAI,CAACE,mBAAmB;YACtB,MAAM,IAAIP,MAAM,CAAC,oBAAoB,EAAEK,cAAc,oBAAoB,CAAC;QAC5E;QAEA,MAAMO,sBAAsB7B,KAAKC,IAAI,CAACK,aAAakB,kBAAkBM,MAAM;QAC3E,MAAMf,SAAS,MAAMC,cAAoCa;QACzD,IAAI,CAACd,QAAQ;YACX,MAAM,IAAIE,MAAM,CAAC,0BAA0B,EAAEY,oBAAoB,iBAAiB,CAAC;QACrF;QACAnB,gBAAgB,CAACY,cAAc,GAAGP;QAClC,OAAOA,OAAOH,UAAU;IAC1B;IACA,OAAO;QACLD;QACAU;IACF;AACF,EAAC;AAED,eAAeL,cAAiBe,QAAgB;IAC9C,IAAIC;IACJ,IAAI;QACFA,QAAQ,MAAMjC,KAAKgC;IACrB,EAAE,OAAM;QACN,sBAAsB;QACtB,OAAOE;IACT;IACA,MAAMC,UAAU,MAAMpC,SAASiC,UAAU;IACzC,MAAMX,eAAeY,MAAMG,KAAK,CAACC,WAAW;IAC5C,MAAMC,OAAOC,KAAKC,KAAK,CAACL;IACxB,IAAI,CAACG,MAAM;QACT,MAAM,IAAIpB,MAAM,CAAC,WAAW,EAAEc,SAAS,YAAY,CAAC;IACtD;IACA,OAAO;QACLX;QACAR,YAAYyB;QACZrC,MAAM+B;IACR;AACF"}

package/dist/actions/schema/utils/schemaStoreOutStrings.d.ts

@@ -1,3 +1,2 @@
 export declare function getDatasetsOutString(datasets: string[]): string;
-export declare function getStringArrayOutString(array: string[]): string;
 export declare function getStringList(array: string[]): string;

package/dist/actions/schema/utils/schemaStoreOutStrings.js

@@ -1,7 +1,7 @@
 export function getDatasetsOutString(datasets) {
     return datasets.length === 1 ? `dataset "${datasets[0]}"` : `datasets ${getStringArrayOutString(datasets)}`;
 }
-export function getStringArrayOutString(array) {
+function getStringArrayOutString(array) {
     return `[${array.map((d)=>`"${d}"`).join(',')}]`;
 }
 export function getStringList(array) {

package/dist/actions/schema/utils/schemaStoreOutStrings.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/actions/schema/utils/schemaStoreOutStrings.ts"],"sourcesContent":["export function getDatasetsOutString(datasets: string[]) {\n  return datasets.length === 1\n    ? `dataset \"${datasets[0]}\"`\n    : `datasets ${getStringArrayOutString(datasets)}`\n}\n\nexport function getStringArrayOutString(array: string[]) {\n  return `[${array.map((d) => `\"${d}\"`).join(',')}]`\n}\n\nexport function getStringList(array: string[]) {\n  return array.map((s) => `- \"${s}\"`).join('\\n')\n}\n"],"names":["getDatasetsOutString","datasets","length","getStringArrayOutString","array","map","d","join","getStringList","s"],"mappings":"AAAA,OAAO,SAASA,qBAAqBC,QAAkB;IACrD,OAAOA,SAASC,MAAM,KAAK,IACvB,CAAC,SAAS,EAAED,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,GAC1B,CAAC,SAAS,EAAEE,wBAAwBF,WAAW;AACrD;AAEA,OAAO,SAASE,wBAAwBC,KAAe;IACrD,OAAO,CAAC,CAAC,EAAEA,MAAMC,GAAG,CAAC,CAACC,IAAM,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpD;AAEA,OAAO,SAASC,cAAcJ,KAAe;IAC3C,OAAOA,MAAMC,GAAG,CAAC,CAACI,IAAM,CAAC,GAAG,EAAEA,EAAE,CAAC,CAAC,EAAEF,IAAI,CAAC;AAC3C"}
+{"version":3,"sources":["../../../../src/actions/schema/utils/schemaStoreOutStrings.ts"],"sourcesContent":["export function getDatasetsOutString(datasets: string[]) {\n  return datasets.length === 1\n    ? `dataset \"${datasets[0]}\"`\n    : `datasets ${getStringArrayOutString(datasets)}`\n}\n\nfunction getStringArrayOutString(array: string[]) {\n  return `[${array.map((d) => `\"${d}\"`).join(',')}]`\n}\n\nexport function getStringList(array: string[]) {\n  return array.map((s) => `- \"${s}\"`).join('\\n')\n}\n"],"names":["getDatasetsOutString","datasets","length","getStringArrayOutString","array","map","d","join","getStringList","s"],"mappings":"AAAA,OAAO,SAASA,qBAAqBC,QAAkB;IACrD,OAAOA,SAASC,MAAM,KAAK,IACvB,CAAC,SAAS,EAAED,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,GAC1B,CAAC,SAAS,EAAEE,wBAAwBF,WAAW;AACrD;AAEA,SAASE,wBAAwBC,KAAe;IAC9C,OAAO,CAAC,CAAC,EAAEA,MAAMC,GAAG,CAAC,CAACC,IAAM,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpD;AAEA,OAAO,SAASC,cAAcJ,KAAe;IAC3C,OAAOA,MAAMC,GAAG,CAAC,CAACI,IAAM,CAAC,GAAG,EAAEA,EAAE,CAAC,CAAC,EAAEF,IAAI,CAAC;AAC3C"}