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

package/dist/commands/documents/__tests__/validate.test.js

@@ -0,0 +1,226 @@
+import { runCommand } from '@oclif/test';
+import { testCommand } from '@sanity/cli-test';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { ValidateDocumentsCommand } from '../validate.js';
+const mocks = vi.hoisted(()=>({
+        confirm: vi.fn(),
+        isFile: vi.fn(),
+        validate: vi.fn()
+    }));
+vi.mock('node:fs', ()=>({
+        default: {
+            promises: {
+                stat: vi.fn().mockResolvedValue({
+                    isFile: mocks.isFile
+                })
+            },
+            resolve: vi.fn((dir, file)=>`/resolved/${file}`)
+        }
+    }));
+vi.mock('@sanity/cli-core/ux', async ()=>{
+    const actual = await vi.importActual('@sanity/cli-core/ux');
+    return {
+        ...actual,
+        confirm: mocks.confirm
+    };
+});
+vi.mock('../../../../../cli-core/src/config/findProjectRoot.js', ()=>({
+        findProjectRoot: vi.fn().mockResolvedValue({
+            directory: '/test/path',
+            root: '/test/path',
+            type: 'studio'
+        })
+    }));
+vi.mock('../../../../../cli-core/src/config/cli/getCliConfig.js', ()=>({
+        getCliConfig: vi.fn()
+    }));
+vi.mock('../../../../../cli-core/src/services/apiClient.js', ()=>({
+        getGlobalCliClient: vi.fn().mockResolvedValue({
+            config: vi.fn(()=>({
+                    dataset: 'test-dataset',
+                    projectId: 'test-project'
+                }))
+        })
+    }));
+vi.mock('../../../actions/documents/validate.js', ()=>({
+        validateDocuments: mocks.validate
+    }));
+const mockConfirm = mocks.confirm;
+const mockIsFile = mocks.isFile;
+const mockValidate = mocks.validate;
+describe('#documents:validate', ()=>{
+    afterEach(()=>{
+        vi.clearAllMocks();
+    });
+    beforeEach(()=>{
+        mockConfirm.mockResolvedValue(true);
+        mockIsFile.mockReturnValue(true);
+    });
+    test('--help works', async ()=>{
+        const { stdout } = await runCommand([
+            'documents validate',
+            '--help'
+        ]);
+        expect(stdout).toMatchInlineSnapshot(`
+      "Validate documents in a dataset against the studio schema
+
+      USAGE
+        $ sanity documents validate [-d <value>] [--file <value>] [--format <value>]
+          [--level error|warning|info] [--max-custom-validation-concurrency <value>]
+          [--max-fetch-concurrency <value>] [--workspace <value>] [-y]
+
+      FLAGS
+        -d, --dataset=<value>                            Override the dataset used. By
+                                                         default, this is derived from
+                                                         the given workspace
+        -y, --yes                                        Skips the first confirmation
+                                                         prompt
+            --file=<value>                               Provide a path to either an
+                                                         .ndjson file or a tarball
+                                                         containing an .ndjson file
+            --format=<value>                             The output format used to
+                                                         print the found validation
+                                                         markers and report progress
+            --level=<option>                             [default: warning] The
+                                                         minimum level reported out.
+                                                         Defaults to warning
+                                                         <options: error|warning|info>
+            --max-custom-validation-concurrency=<value>  [default: 5] Specify how many
+                                                         custom validators can run
+                                                         concurrently
+            --max-fetch-concurrency=<value>              [default: 25] Specify how
+                                                         many \`client.fetch\` requests
+                                                         are allow concurrency at once
+            --workspace=<value>                          The name of the workspace to
+                                                         use when downloading and
+                                                         validating all documents
+
+      DESCRIPTION
+        Validate documents in a dataset against the studio schema
+
+      EXAMPLES
+        Validates all documents in a Sanity project with more than one workspace
+
+          $ sanity documents validate --workspace default
+
+        Override the dataset specified in the workspace
+
+          $ sanity documents validate --workspace default --dataset staging
+
+        Save the results of the report into a file
+
+          $ sanity documents validate --yes > report.txt
+
+        Report out info level validation markers too
+
+          $ sanity documents validate --level info
+
+      "
+    `);
+    });
+    test('throws error if user enters unsupported level flag', async ()=>{
+        const { error } = await testCommand(ValidateDocumentsCommand, [
+            '--level',
+            'critical'
+        ]);
+        expect(error?.message).toContain('Expected --level=critical to be one of: error, warning, info');
+    });
+    test('throws error if user enters non integer max-custom-validation-concurrency flag', async ()=>{
+        const { error } = await testCommand(ValidateDocumentsCommand, [
+            '--max-custom-validation-concurrency',
+            'abc'
+        ]);
+        expect(error?.message).toContain('Expected an integer but received: abc');
+    });
+    test('throws error if user enters non integer max-fetch-concurrency flag', async ()=>{
+        const { error } = await testCommand(ValidateDocumentsCommand, [
+            '--max-fetch-concurrency',
+            'xyz'
+        ]);
+        expect(error?.message).toContain('Expected an integer but received: xyz');
+    });
+    test('prompts user to confirm by default and exits if they do not want to continue', async ()=>{
+        mockConfirm.mockResolvedValue(false);
+        const { stdout } = await testCommand(ValidateDocumentsCommand, []);
+        expect(stdout).toMatchInlineSnapshot(`
+      "⚠ Warning: This command downloads all documents from your dataset and processes them through your local schema within a simulated browser environment.
+
+      Potential pitfalls:
+
+      - Processes all documents locally (excluding assets). Large datasets may require more resources.
+      - Executes all custom validation functions. Some functions may need to be refactored for compatibility.
+      - Not all standard browser features are available and may cause issues while loading your Studio.
+      - Adheres to document permissions. Ensure this account can see all desired documents.
+      User aborted
+      "
+    `);
+        expect(mockConfirm).toHaveBeenCalledWith({
+            default: true,
+            message: expect.stringContaining('Are you sure you want to continue?')
+        });
+        expect(mockConfirm).toHaveBeenCalled();
+    });
+    test('skips confirm if user uses yes flag', async ()=>{
+        await testCommand(ValidateDocumentsCommand, [
+            '--y'
+        ]);
+        expect(mockConfirm).not.toHaveBeenCalled();
+    });
+    test('exits if format is incorrect value', async ()=>{
+        const { error } = await testCommand(ValidateDocumentsCommand, [
+            '--format',
+            'xml'
+        ]);
+        expect(error?.message).toContain("Did not recognize format 'xml'. Available formats are 'json', 'ndjson', and 'pretty'");
+    });
+    test('exits if user inputs invalid file path in flag', async ()=>{
+        mockIsFile.mockReturnValue(false);
+        const { error } = await testCommand(ValidateDocumentsCommand, [
+            '--file',
+            '/non/existent/file.ndjson'
+        ]);
+        expect(error?.message).toContain("'--file' must point to a valid ndjson file or tarball");
+    });
+    test('validateDocuments is called with the correct params', async ()=>{
+        mockValidate.mockResolvedValue('warning');
+        await testCommand(ValidateDocumentsCommand, [
+            '--yes',
+            '--dataset',
+            'my-dataset',
+            '--workspace',
+            'my-workspace',
+            '--level',
+            'info',
+            '--max-custom-validation-concurrency',
+            '10',
+            '--max-fetch-concurrency',
+            '50',
+            '--file',
+            '/path/to/file.ndjson'
+        ]);
+        expect(mockValidate).toHaveBeenCalledWith({
+            clientConfig: expect.any(Object),
+            dataset: 'my-dataset',
+            level: 'info',
+            maxCustomValidationConcurrency: 10,
+            maxFetchConcurrency: 50,
+            ndjsonFilePath: expect.stringContaining('file.ndjson'),
+            reporter: expect.any(Function),
+            studioHost: undefined,
+            workDir: '/test/path',
+            workspace: 'my-workspace'
+        });
+    });
+    test('exits with code 1 if validateDocuments returns overall level as error', async ()=>{
+        mockValidate.mockResolvedValue('error');
+        const { error } = await testCommand(ValidateDocumentsCommand, []);
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('exits with code 0 if validateDocuments does not return overall level as error', async ()=>{
+        mockValidate.mockResolvedValue('warning');
+        const { error } = await testCommand(ValidateDocumentsCommand, []);
+        expect(error).toBe(undefined);
+    });
+});
+
+//# sourceMappingURL=validate.test.js.map

package/dist/commands/documents/__tests__/validate.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/documents/__tests__/validate.test.ts"],"sourcesContent":["import {runCommand} from '@oclif/test'\nimport {testCommand} from '@sanity/cli-test'\nimport {afterEach, beforeEach, describe, expect, test, vi} from 'vitest'\n\nimport {ValidateDocumentsCommand} from '../validate.js'\n\nconst mocks = vi.hoisted(() => ({\n  confirm: vi.fn(),\n  isFile: vi.fn(),\n  validate: vi.fn(),\n}))\n\nvi.mock('node:fs', () => ({\n  default: {\n    promises: {\n      stat: vi.fn().mockResolvedValue({\n        isFile: mocks.isFile,\n      }),\n    },\n    resolve: vi.fn((dir, file) => `/resolved/${file}`),\n  },\n}))\n\nvi.mock('@sanity/cli-core/ux', async () => {\n  const actual = await vi.importActual<typeof import('@sanity/cli-core/ux')>('@sanity/cli-core/ux')\n  return {\n    ...actual,\n    confirm: mocks.confirm,\n  }\n})\n\nvi.mock('../../../../../cli-core/src/config/findProjectRoot.js', () => ({\n  findProjectRoot: vi.fn().mockResolvedValue({\n    directory: '/test/path',\n    root: '/test/path',\n    type: 'studio',\n  }),\n}))\n\nvi.mock('../../../../../cli-core/src/config/cli/getCliConfig.js', () => ({\n  getCliConfig: vi.fn(),\n}))\n\nvi.mock('../../../../../cli-core/src/services/apiClient.js', () => ({\n  getGlobalCliClient: vi.fn().mockResolvedValue({\n    config: vi.fn(() => ({\n      dataset: 'test-dataset',\n      projectId: 'test-project',\n    })),\n  }),\n}))\n\nvi.mock('../../../actions/documents/validate.js', () => ({\n  validateDocuments: mocks.validate,\n}))\n\nconst mockConfirm = mocks.confirm\nconst mockIsFile = mocks.isFile\nconst mockValidate = mocks.validate\n\ndescribe('#documents:validate', () => {\n  afterEach(() => {\n    vi.clearAllMocks()\n  })\n  beforeEach(() => {\n    mockConfirm.mockResolvedValue(true)\n    mockIsFile.mockReturnValue(true)\n  })\n\n  test('--help works', async () => {\n    const {stdout} = await runCommand(['documents validate', '--help'])\n\n    expect(stdout).toMatchInlineSnapshot(`\n      \"Validate documents in a dataset against the studio schema\n\n      USAGE\n        $ sanity documents validate [-d <value>] [--file <value>] [--format <value>]\n          [--level error|warning|info] [--max-custom-validation-concurrency <value>]\n          [--max-fetch-concurrency <value>] [--workspace <value>] [-y]\n\n      FLAGS\n        -d, --dataset=<value>                            Override the dataset used. By\n                                                         default, this is derived from\n                                                         the given workspace\n        -y, --yes                                        Skips the first confirmation\n                                                         prompt\n            --file=<value>                               Provide a path to either an\n                                                         .ndjson file or a tarball\n                                                         containing an .ndjson file\n            --format=<value>                             The output format used to\n                                                         print the found validation\n                                                         markers and report progress\n            --level=<option>                             [default: warning] The\n                                                         minimum level reported out.\n                                                         Defaults to warning\n                                                         <options: error|warning|info>\n            --max-custom-validation-concurrency=<value>  [default: 5] Specify how many\n                                                         custom validators can run\n                                                         concurrently\n            --max-fetch-concurrency=<value>              [default: 25] Specify how\n                                                         many \\`client.fetch\\` requests\n                                                         are allow concurrency at once\n            --workspace=<value>                          The name of the workspace to\n                                                         use when downloading and\n                                                         validating all documents\n\n      DESCRIPTION\n        Validate documents in a dataset against the studio schema\n\n      EXAMPLES\n        Validates all documents in a Sanity project with more than one workspace\n\n          $ sanity documents validate --workspace default\n\n        Override the dataset specified in the workspace\n\n          $ sanity documents validate --workspace default --dataset staging\n\n        Save the results of the report into a file\n\n          $ sanity documents validate --yes > report.txt\n\n        Report out info level validation markers too\n\n          $ sanity documents validate --level info\n\n      \"\n    `)\n  })\n\n  test('throws error if user enters unsupported level flag', async () => {\n    const {error} = await testCommand(ValidateDocumentsCommand, ['--level', 'critical'])\n\n    expect(error?.message).toContain('Expected --level=critical to be one of: error, warning, info')\n  })\n\n  test('throws error if user enters non integer max-custom-validation-concurrency flag', async () => {\n    const {error} = await testCommand(ValidateDocumentsCommand, [\n      '--max-custom-validation-concurrency',\n      'abc',\n    ])\n\n    expect(error?.message).toContain('Expected an integer but received: abc')\n  })\n\n  test('throws error if user enters non integer max-fetch-concurrency flag', async () => {\n    const {error} = await testCommand(ValidateDocumentsCommand, ['--max-fetch-concurrency', 'xyz'])\n\n    expect(error?.message).toContain('Expected an integer but received: xyz')\n  })\n\n  test('prompts user to confirm by default and exits if they do not want to continue', async () => {\n    mockConfirm.mockResolvedValue(false)\n\n    const {stdout} = await testCommand(ValidateDocumentsCommand, [])\n\n    expect(stdout).toMatchInlineSnapshot(`\n      \"⚠ Warning: This command downloads all documents from your dataset and processes them through your local schema within a simulated browser environment.\n\n      Potential pitfalls:\n\n      - Processes all documents locally (excluding assets). Large datasets may require more resources.\n      - Executes all custom validation functions. Some functions may need to be refactored for compatibility.\n      - Not all standard browser features are available and may cause issues while loading your Studio.\n      - Adheres to document permissions. Ensure this account can see all desired documents.\n      User aborted\n      \"\n    `)\n    expect(mockConfirm).toHaveBeenCalledWith({\n      default: true,\n      message: expect.stringContaining('Are you sure you want to continue?'),\n    })\n    expect(mockConfirm).toHaveBeenCalled()\n  })\n\n  test('skips confirm if user uses yes flag', async () => {\n    await testCommand(ValidateDocumentsCommand, ['--y'])\n\n    expect(mockConfirm).not.toHaveBeenCalled()\n  })\n\n  test('exits if format is incorrect value', async () => {\n    const {error} = await testCommand(ValidateDocumentsCommand, ['--format', 'xml'])\n\n    expect(error?.message).toContain(\n      \"Did not recognize format 'xml'. Available formats are 'json', 'ndjson', and 'pretty'\",\n    )\n  })\n\n  test('exits if user inputs invalid file path in flag', async () => {\n    mockIsFile.mockReturnValue(false)\n\n    const {error} = await testCommand(ValidateDocumentsCommand, [\n      '--file',\n      '/non/existent/file.ndjson',\n    ])\n\n    expect(error?.message).toContain(\"'--file' must point to a valid ndjson file or tarball\")\n  })\n\n  test('validateDocuments is called with the correct params', async () => {\n    mockValidate.mockResolvedValue('warning')\n\n    await testCommand(ValidateDocumentsCommand, [\n      '--yes',\n      '--dataset',\n      'my-dataset',\n      '--workspace',\n      'my-workspace',\n      '--level',\n      'info',\n      '--max-custom-validation-concurrency',\n      '10',\n      '--max-fetch-concurrency',\n      '50',\n      '--file',\n      '/path/to/file.ndjson',\n    ])\n\n    expect(mockValidate).toHaveBeenCalledWith({\n      clientConfig: expect.any(Object),\n      dataset: 'my-dataset',\n      level: 'info',\n      maxCustomValidationConcurrency: 10,\n      maxFetchConcurrency: 50,\n      ndjsonFilePath: expect.stringContaining('file.ndjson'),\n      reporter: expect.any(Function),\n      studioHost: undefined,\n      workDir: '/test/path',\n      workspace: 'my-workspace',\n    })\n  })\n\n  test('exits with code 1 if validateDocuments returns overall level as error', async () => {\n    mockValidate.mockResolvedValue('error')\n\n    const {error} = await testCommand(ValidateDocumentsCommand, [])\n\n    expect(error?.oclif?.exit).toBe(1)\n  })\n\n  test('exits with code 0 if validateDocuments does not return overall level as error', async () => {\n    mockValidate.mockResolvedValue('warning')\n\n    const {error} = await testCommand(ValidateDocumentsCommand, [])\n\n    expect(error).toBe(undefined)\n  })\n})\n"],"names":["runCommand","testCommand","afterEach","beforeEach","describe","expect","test","vi","ValidateDocumentsCommand","mocks","hoisted","confirm","fn","isFile","validate","mock","default","promises","stat","mockResolvedValue","resolve","dir","file","actual","importActual","findProjectRoot","directory","root","type","getCliConfig","getGlobalCliClient","config","dataset","projectId","validateDocuments","mockConfirm","mockIsFile","mockValidate","clearAllMocks","mockReturnValue","stdout","toMatchInlineSnapshot","error","message","toContain","toHaveBeenCalledWith","stringContaining","toHaveBeenCalled","not","clientConfig","any","Object","level","maxCustomValidationConcurrency","maxFetchConcurrency","ndjsonFilePath","reporter","Function","studioHost","undefined","workDir","workspace","oclif","exit","toBe"],"mappings":"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"}

package/dist/commands/documents/create.d.ts

@@ -0,0 +1,38 @@
+import { SanityCommand } from '@sanity/cli-core';
+export type MutationOperationName = 'create' | 'createIfNotExists' | 'createOrReplace';
+export declare class CreateDocumentCommand extends SanityCommand<typeof CreateDocumentCommand> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json5: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        missing: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        replace: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        watch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private getErrorMessage;
+    /**
+     * Formats the result message for document operations
+     */
+    private getResultMessage;
+    /**
+     * Reads and processes documents from a file for creation
+     */
+    private readAndPerformCreatesFromFile;
+    /**
+     * Validates a document for Sanity requirements
+     */
+    private validateDocument;
+    /**
+     * Writes documents to Sanity using the specified operation
+     */
+    private writeDocuments;
+}

package/dist/commands/documents/create.js

@@ -0,0 +1,337 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Args, Flags } from '@oclif/core';
+import { SanityCommand, subdebug } from '@sanity/cli-core';
+import { watch as chokidarWatch } from 'chokidar';
+import { execa, execaSync } from 'execa';
+import json5 from 'json5';
+import { isEqual, isPlainObject } from 'lodash-es';
+import { DOCUMENTS_API_VERSION } from '../../actions/documents/constants.js';
+import { getEditor, registerUnlinkOnSigInt } from '../../actions/documents/editor.js';
+import { NO_PROJECT_ID } from '../../util/errorMessages.js';
+import { isIdentifiedSanityDocument, isSanityDocumentish } from '../../util/isSanityDocumentish.js';
+const createDocumentDebug = subdebug('documents:create');
+export class CreateDocumentCommand extends SanityCommand {
+    static args = {
+        file: Args.string({
+            description: 'JSON file to create document(s) from',
+            required: false
+        })
+    };
+    static description = 'Create one or more documents';
+    static examples = [
+        {
+            command: '<%= config.bin %> <%= command.id %> myDocument.json',
+            description: 'Create the document specified in "myDocument.json"'
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %>',
+            description: 'Open configured $EDITOR and create the specified document(s)'
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --id myDocId --replace',
+            description: 'Fetch document with the ID "myDocId" and open configured $EDITOR with the current document content (if any). Replace document with the edited version when the editor closes'
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --id myDocId --watch --replace --json5',
+            description: 'Open configured $EDITOR and replace the document with the given content on each save. Use JSON5 file extension and parser for simplified syntax.'
+        }
+    ];
+    static flags = {
+        dataset: Flags.string({
+            char: 'd',
+            description: 'Dataset to create document(s) in (overrides config)'
+        }),
+        id: Flags.string({
+            description: 'Specify a document ID to use. Will fetch remote document ID and populate editor.'
+        }),
+        json5: Flags.boolean({
+            description: 'Use JSON5 file type to allow a "simplified" version of JSON'
+        }),
+        missing: Flags.boolean({
+            description: "On duplicate document IDs, don't modify the target document(s)"
+        }),
+        replace: Flags.boolean({
+            description: 'On duplicate document IDs, replace existing document with specified document(s)'
+        }),
+        watch: Flags.boolean({
+            description: 'Write the documents whenever the target file or buffer changes'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(CreateDocumentCommand);
+        const { file } = args;
+        const { dataset, id, json5: useJson5, missing, replace, watch } = flags;
+        const cliConfig = await this.getCliConfig();
+        const projectId = await this.getProjectId();
+        if (!projectId) {
+            this.error(NO_PROJECT_ID, {
+                exit: 1
+            });
+        }
+        if (!cliConfig.api?.dataset && !dataset) {
+            this.error('No dataset specified. Either configure a dataset in sanity.cli.ts or use the --dataset flag', {
+                exit: 1
+            });
+        }
+        const targetDataset = dataset || cliConfig.api?.dataset;
+        const client = await this.getProjectApiClient({
+            apiVersion: DOCUMENTS_API_VERSION,
+            dataset: targetDataset,
+            projectId,
+            requireUser: true
+        });
+        if (replace && missing) {
+            this.error('Cannot use both --replace and --missing', {
+                exit: 1
+            });
+        }
+        if (id && file) {
+            this.error('Cannot use --id when specifying a file path', {
+                exit: 1
+            });
+        }
+        let operation = 'create';
+        if (replace || missing) {
+            operation = replace ? 'createOrReplace' : 'createIfNotExists';
+        }
+        if (file) {
+            try {
+                const contentPath = path.resolve(process.cwd(), file);
+                const content = json5.parse(await fs.readFile(contentPath, 'utf8'));
+                const result = await this.writeDocuments(content, operation, client);
+                this.log(this.getResultMessage(result, operation));
+                return;
+            } catch (error) {
+                const err = error;
+                createDocumentDebug(`Error creating documents from file ${file}`, err);
+                this.error(`Failed to create documents: ${err.message}`, {
+                    exit: 1
+                });
+            }
+        }
+        try {
+            // Create a temporary file and use that as source, opening an editor on it
+            const docId = id || randomUUID();
+            const ext = useJson5 ? 'json5' : 'json';
+            // Add UUID prefix to prevent predictable file names and potential conflicts
+            const tmpFile = path.join(os.tmpdir(), 'sanity-cli', `${randomUUID()}-${docId}.${ext}`);
+            const stringify = useJson5 ? json5.stringify : JSON.stringify;
+            const defaultValue = id && await client.getDocument(id) || {
+                _id: docId,
+                _type: 'specify-me'
+            };
+            // Create temp directory with restricted permissions (owner only)
+            const tempDir = path.join(os.tmpdir(), 'sanity-cli');
+            await fs.mkdir(tempDir, {
+                mode: 0o700,
+                recursive: true
+            });
+            // Write file with restricted permissions (owner read/write only)
+            await fs.writeFile(tmpFile, stringify(defaultValue, null, 2), {
+                encoding: 'utf8',
+                mode: 0o600
+            });
+            const editor = getEditor();
+            const readAndPerformCreatesFromFile = this.readAndPerformCreatesFromFile.bind(this, operation, client);
+            if (watch) {
+                // If we're in watch mode, we want to run the creation on each change (if it validates)
+                registerUnlinkOnSigInt(tmpFile);
+                this.log(`Watch mode: ${tmpFile}`);
+                this.log('Watch mode: Will write documents on each save.');
+                this.log('Watch mode: Press Ctrl + C to cancel watch mode.');
+                // Add race condition protection
+                let isProcessing = false;
+                chokidarWatch(tmpFile).on('change', async ()=>{
+                    if (isProcessing) {
+                        return; // Skip if already processing
+                    }
+                    isProcessing = true;
+                    this.log('');
+                    try {
+                        await readAndPerformCreatesFromFile(tmpFile, defaultValue);
+                    } finally{
+                        isProcessing = false;
+                    }
+                });
+                execa(editor.bin, [
+                    ...editor.args,
+                    tmpFile
+                ], {
+                    stdio: 'inherit'
+                });
+            } else {
+                // While in normal mode, we just want to wait for the editor to close and run the thing once
+                execaSync(editor.bin, [
+                    ...editor.args,
+                    tmpFile
+                ], {
+                    stdio: 'inherit'
+                });
+                await readAndPerformCreatesFromFile(tmpFile, defaultValue);
+                await fs.unlink(tmpFile).catch(()=>{});
+            }
+        } catch (error) {
+            const err = error;
+            createDocumentDebug('Error in editor workflow', err);
+            this.error(`Failed to create documents: ${err.message}`, {
+                exit: 1
+            });
+        }
+    }
+    getErrorMessage(message, index, isSingle) {
+        return isSingle ? `Document ${message}` : `Document at index ${index} ${message}`;
+    }
+    /**
+   * Formats the result message for document operations
+   */ getResultMessage(result, operation) {
+        const joiner = '\n  - ';
+        if (operation === 'createOrReplace') {
+            return `Upserted:\n  - ${result.results.map((res)=>res.id).join(joiner)}`;
+        }
+        if (operation === 'create') {
+            return `Created:\n  - ${result.results.map((res)=>res.id).join(joiner)}`;
+        }
+        // "Missing" (createIfNotExists)
+        const created = [];
+        const skipped = [];
+        for (const res of result.results){
+            if (res.operation === 'update') {
+                skipped.push(res.id);
+            } else {
+                created.push(res.id);
+            }
+        }
+        if (created.length > 0 && skipped.length > 0) {
+            return [
+                `Created:\n  - ${created.join(joiner)}`,
+                `Skipped (already exists):${joiner}${skipped.join(joiner)}`
+            ].join('\n\n');
+        } else if (created.length > 0) {
+            return `Created:\n  - ${created.join(joiner)}`;
+        }
+        return `Skipped (already exists):\n  - ${skipped.join(joiner)}`;
+    }
+    /**
+   * Reads and processes documents from a file for creation
+   */ async readAndPerformCreatesFromFile(operation, client, filePath, defaultValue) {
+        let content;
+        try {
+            content = json5.parse(await fs.readFile(filePath, 'utf8'));
+        } catch (err) {
+            const error = err;
+            createDocumentDebug(`Failed to read input file ${filePath}`, error);
+            this.log(`Failed to read input: ${error.message}`);
+            return;
+        }
+        if (isEqual(content, defaultValue)) {
+            this.log('Value not modified, doing nothing.');
+            this.log('Modify document to trigger creation.');
+            return;
+        }
+        try {
+            const writeResult = await this.writeDocuments(content, operation, client);
+            this.log(this.getResultMessage(writeResult, operation));
+        } catch (err) {
+            const error = err;
+            createDocumentDebug(`Failed to write documents`, error);
+            let errorMessage = `Failed to write documents: ${error.message}`;
+            if (error.message.includes('already exists')) {
+                errorMessage += '\nPerhaps you want to use `--replace` or `--missing`?';
+            }
+            this.error(errorMessage, {
+                exit: 1
+            });
+        }
+    }
+    /**
+   * Validates a document for Sanity requirements
+   */ validateDocument(doc, index, arr) {
+        const isSingle = arr.length === 1;
+        if (!isPlainObject(doc)) {
+            throw new Error(this.getErrorMessage('must be an object', index, isSingle));
+        }
+        if (!isSanityDocumentish(doc)) {
+            throw new Error(this.getErrorMessage('must have a `_type` property of type string', index, isSingle));
+        }
+        // Enhanced validations for Sanity document constraints
+        const docObj = doc;
+        // Validate _type is non-empty
+        const typeValue = docObj._type?.toString().trim();
+        if (!typeValue) {
+            throw new Error(this.getErrorMessage('_type cannot be empty', index, isSingle));
+        }
+        // Validate _type format (alphanumeric, underscore, hyphen, dot)
+        if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(typeValue)) {
+            throw new Error(this.getErrorMessage('_type must start with a letter and contain only alphanumeric characters, underscores, hyphens, and dots', index, isSingle));
+        }
+        // Validate _id format if present
+        if (docObj._id && typeof docObj._id === 'string') {
+            const idValue = docObj._id.trim();
+            if (!idValue) {
+                throw new Error(this.getErrorMessage('_id cannot be empty', index, isSingle));
+            }
+            // Sanity document IDs can contain alphanumeric chars, hyphens, underscores, and dots
+            if (!/^[a-zA-Z0-9_.-]+$/.test(idValue)) {
+                throw new Error(this.getErrorMessage('_id can only contain alphanumeric characters, underscores, hyphens, and dots', index, isSingle));
+            }
+            // Check length constraints (Sanity has reasonable limits)
+            if (idValue.length > 200) {
+                throw new Error(this.getErrorMessage('_id cannot be longer than 200 characters', index, isSingle));
+            }
+        }
+        // Warn about reserved fields (these are managed by Sanity)
+        const reservedFields = [
+            '_rev',
+            '_updatedAt',
+            '_createdAt'
+        ];
+        for (const field of reservedFields){
+            if (field in docObj) {
+                // Note: We don't throw an error here as these might be present in fetched documents
+                // that are being re-uploaded, but we could add a debug warning
+                createDocumentDebug(`Warning: Document ${index} contains reserved field '${field}' which will be ignored by Sanity`);
+            }
+        }
+    }
+    /**
+   * Writes documents to Sanity using the specified operation
+   */ async writeDocuments(documents, operation, client) {
+        const docs = Array.isArray(documents) ? documents : [
+            documents
+        ];
+        if (docs.length === 0) {
+            throw new Error('No documents provided');
+        }
+        const mutations = docs.map((doc, index)=>{
+            this.validateDocument(doc, index, docs);
+            if (operation === 'create') {
+                return {
+                    create: doc
+                };
+            }
+            if (operation === 'createIfNotExists') {
+                if (isIdentifiedSanityDocument(doc)) {
+                    return {
+                        createIfNotExists: doc
+                    };
+                }
+                throw new Error(`Missing required _id attribute for ${operation}`);
+            }
+            if (operation === 'createOrReplace') {
+                if (isIdentifiedSanityDocument(doc)) {
+                    return {
+                        createOrReplace: doc
+                    };
+                }
+                throw new Error(`Missing required _id attribute for ${operation}`);
+            }
+            throw new Error(`Unsupported operation ${operation}`);
+        });
+        return client.transaction(mutations).commit();
+    }
+}
+
+//# sourceMappingURL=create.js.map