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

package/templates/shopify-online-storefront/schemaTypes/objects/shopifyProductVariant.ts

@@ -0,0 +1,151 @@
+import {defineField, defineType} from 'sanity'
+
+export default defineType({
+  name: 'shopifyProductVariant',
+  title: 'Shopify',
+  type: 'object',
+  options: {
+    collapsed: false,
+    collapsible: true,
+  },
+  fieldsets: [
+    {
+      name: 'options',
+      title: 'Options',
+      options: {
+        columns: 3,
+      },
+    },
+    {
+      name: 'status',
+      title: 'Status',
+    },
+  ],
+  fields: [
+    // Created at
+    defineField({
+      fieldset: 'status',
+      name: 'createdAt',
+      title: 'Created at',
+      type: 'string',
+    }),
+    // Updated at
+    defineField({
+      fieldset: 'status',
+      name: 'updatedAt',
+      title: 'Updated at',
+      type: 'string',
+    }),
+    // Product status
+    defineField({
+      fieldset: 'status',
+      name: 'status',
+      title: 'Product status',
+      type: 'string',
+      options: {
+        layout: 'dropdown',
+        list: ['active', 'archived', 'draft'],
+      },
+      validation: (Rule) => Rule.required(),
+    }),
+    // Deleted
+    defineField({
+      fieldset: 'status',
+      name: 'isDeleted',
+      title: 'Deleted from Shopify?',
+      type: 'boolean',
+    }),
+    // Title
+    defineField({
+      name: 'title',
+      title: 'Title',
+      type: 'string',
+    }),
+    // SKU
+    defineField({
+      name: 'sku',
+      title: 'SKU',
+      type: 'string',
+    }),
+    // ID
+    defineField({
+      name: 'id',
+      title: 'ID',
+      type: 'number',
+      description: 'Shopify Product Variant ID',
+    }),
+    // GID
+    defineField({
+      name: 'gid',
+      title: 'GID',
+      type: 'string',
+      description: 'Shopify Product Variant GID',
+    }),
+    // Product ID
+    defineField({
+      name: 'productId',
+      title: 'Product ID',
+      type: 'number',
+    }),
+    // Product GID
+    defineField({
+      name: 'productGid',
+      title: 'Product GID',
+      type: 'string',
+    }),
+    // Price
+    defineField({
+      name: 'price',
+      title: 'Price',
+      type: 'number',
+    }),
+    // Compare at price
+    defineField({
+      name: 'compareAtPrice',
+      title: 'Compare at price',
+      type: 'number',
+    }),
+    // Inventory
+    defineField({
+      name: 'inventory',
+      title: 'Inventory',
+      type: 'inventory',
+    }),
+    // Option 1
+    defineField({
+      fieldset: 'options',
+      name: 'option1',
+      title: 'Option 1',
+      type: 'string',
+    }),
+    // Option 2
+    defineField({
+      fieldset: 'options',
+      name: 'option2',
+      title: 'Option 2',
+      type: 'string',
+    }),
+    // Option 3
+    defineField({
+      fieldset: 'options',
+      name: 'option3',
+      title: 'Option 3',
+      type: 'string',
+    }),
+    // Preview Image URL
+    defineField({
+      name: 'previewImageUrl',
+      title: 'Preview Image URL',
+      type: 'string',
+      description: 'Image displayed in both cart and checkout',
+    }),
+    // Shop details
+    defineField({
+      name: 'shop',
+      title: 'Shop',
+      type: 'shop',
+      description: 'Shopify Shop details',
+    }),
+  ],
+  readOnly: true,
+})

package/templates/shopify-online-storefront/structure/collectionStructure.ts

@@ -0,0 +1,9 @@
+import {ListItemBuilder} from 'sanity/structure'
+import defineStructure from '../utils/defineStructure'
+
+export default defineStructure<ListItemBuilder>((S) =>
+  S.listItem()
+    .title('Collections')
+    .schemaType('collection')
+    .child(S.documentTypeList('collection')),
+)

package/templates/shopify-online-storefront/structure/index.ts

@@ -0,0 +1,37 @@
+import {ListItemBuilder, StructureResolver} from 'sanity/structure'
+import collections from './collectionStructure'
+import products from './productStructure'
+
+/**
+ * Structure overrides
+ *
+ * Sanity Studio automatically lists document types out of the box.
+ * With this custom structure we achieve things like showing the `home`
+ * and `settings` document types as singletons, and grouping product details
+ * and variants for easy editorial access.
+ *
+ * You can customize this even further as your schemas progress.
+ * To learn more about structure builder, visit our docs:
+ * https://www.sanity.io/docs/overview-structure-builder
+ */
+
+// If you add document types to structure manually, you can add them to this function to prevent duplicates in the root pane
+const hiddenDocTypes = (listItem: ListItemBuilder) => {
+  const id = listItem.getId()
+
+  if (!id) {
+    return false
+  }
+
+  return !['collection', 'media.tag', 'product', 'productVariant', 'vendor'].includes(id)
+}
+
+export const structure: StructureResolver = (S, context) =>
+  S.list()
+    .title('Content')
+    .items([
+      collections(S, context),
+      products(S, context),
+      S.divider(),
+      ...S.documentTypeListItems().filter(hiddenDocTypes),
+    ])

package/templates/shopify-online-storefront/structure/productStructure.ts

@@ -0,0 +1,35 @@
+import {InfoOutlineIcon} from '@sanity/icons'
+import {ListItemBuilder} from 'sanity/structure'
+import defineStructure from '../utils/defineStructure'
+
+export default defineStructure<ListItemBuilder>((S) =>
+  S.listItem()
+    .title('Products')
+    .schemaType('product')
+    .child(
+      S.documentTypeList('product').child((id) =>
+        S.list()
+          .title('Product')
+          .items([
+            // Details
+            S.listItem()
+              .title('Details')
+              .icon(InfoOutlineIcon)
+              .child(S.document().schemaType('product').documentId(id)),
+            // Product variants
+            S.listItem()
+              .title('Variants')
+              .schemaType('productVariant')
+              .child(
+                S.documentList()
+                  .title('Variants')
+                  .schemaType('productVariant')
+                  .filter(`_type == "productVariant" && store.productId == $productId`)
+                  .params({
+                    productId: Number(id.replace('shopifyProduct-', '')),
+                  }),
+              ),
+          ]),
+      ),
+    ),
+)

package/templates/shopify-online-storefront/utils/defineStructure.ts

@@ -0,0 +1,11 @@
+import {ConfigContext} from 'sanity'
+import {StructureBuilder} from 'sanity/structure'
+
+/**
+ * Helper for creating and typing composable structure parts.
+ */
+export default function defineStructure<StructureType>(
+  factory: (S: StructureBuilder, context: ConfigContext) => StructureType,
+) {
+  return factory
+}

package/templates/shopify-online-storefront/utils/getPriceRange.ts

@@ -0,0 +1,24 @@
+import {DEFAULT_CURRENCY_CODE} from '../constants'
+
+type PriceObject = {
+  minVariantPrice: number
+  maxVariantPrice: number
+}
+
+const formatNumber = (val: number) => {
+  return new Intl.NumberFormat('en', {
+    currency: DEFAULT_CURRENCY_CODE,
+    style: 'currency',
+  }).format(val)
+}
+
+export const getPriceRange = (price: PriceObject) => {
+  if (!price || typeof price?.minVariantPrice === 'undefined') {
+    return 'No price found'
+  }
+  if (price.maxVariantPrice && price.minVariantPrice !== price.maxVariantPrice) {
+    return `${formatNumber(price.minVariantPrice)} – ${formatNumber(price.maxVariantPrice)}`
+  }
+
+  return formatNumber(price.minVariantPrice)
+}

package/templates/shopify-online-storefront/utils/shopifyUrls.ts

@@ -0,0 +1,22 @@
+import {SHOPIFY_STORE_ID} from '../constants'
+
+export const collectionUrl = (collectionId: number) => {
+  if (!SHOPIFY_STORE_ID) {
+    return null
+  }
+  return `https://${SHOPIFY_STORE_ID}/admin/collections/${collectionId}`
+}
+
+export const productUrl = (productId: number) => {
+  if (!SHOPIFY_STORE_ID) {
+    return null
+  }
+  return `https://${SHOPIFY_STORE_ID}/admin/products/${productId}`
+}
+
+export const productVariantUrl = (productId: number, productVariantId: number) => {
+  if (!SHOPIFY_STORE_ID) {
+    return null
+  }
+  return `https://${SHOPIFY_STORE_ID}/admin/products/${productId}/variants/${productVariantId}`
+}

package/dist/actions/build/__tests__/buildApp.test.js

@@ -1,367 +0,0 @@
-import { rm } from 'node:fs/promises';
-import { logSymbols } from '@sanity/cli-core/ux';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { buildApp } from '../buildApp.js';
-vi.mock('node:fs/promises');
-vi.mock('@sanity/cli-core/ux', async ()=>{
-    const original = await import('@sanity/cli-core/ux');
-    return {
-        ...original,
-        confirm: mockedConfirm,
-        spinner: vi.fn(()=>({
-                fail: vi.fn().mockReturnThis(),
-                start: vi.fn().mockReturnThis(),
-                succeed: vi.fn().mockReturnThis(),
-                text: ''
-            }))
-    };
-});
-vi.mock('../../../util/compareDependencyVersions.js');
-vi.mock('../../../util/readModuleVersion.js');
-vi.mock('../buildStaticFiles.js');
-vi.mock('../buildVendorDependencies.js');
-vi.mock('../getAppEnvVars.js');
-vi.mock('../getAutoUpdatesImportMap.js');
-const mockedRm = rm;
-const mockedConfirm = vi.hoisted(()=>vi.fn());
-const mockedCompareDependencyVersions = vi.hoisted(()=>vi.fn());
-const mockedReadModuleVersion = vi.hoisted(()=>vi.fn());
-const mockedBuildStaticFiles = vi.hoisted(()=>vi.fn());
-const mockedBuildVendorDependencies = vi.hoisted(()=>vi.fn());
-const mockedGetAppEnvVars = vi.hoisted(()=>vi.fn());
-const mockedGetAutoUpdatesImportMap = vi.hoisted(()=>vi.fn());
-vi.mock('../../../util/compareDependencyVersions.js', ()=>({
-        compareDependencyVersions: mockedCompareDependencyVersions
-    }));
-vi.mock('../../../util/readModuleVersion.js', ()=>({
-        readModuleVersion: mockedReadModuleVersion
-    }));
-vi.mock('../buildStaticFiles.js', ()=>({
-        buildStaticFiles: mockedBuildStaticFiles
-    }));
-vi.mock('../buildVendorDependencies.js', ()=>({
-        buildVendorDependencies: mockedBuildVendorDependencies
-    }));
-vi.mock('../getAppEnvVars.js', ()=>({
-        getAppEnvVars: mockedGetAppEnvVars
-    }));
-vi.mock('../getAutoUpdatesImportMap.js', ()=>({
-        getAutoUpdatesImportMap: mockedGetAutoUpdatesImportMap
-    }));
-describe('buildApp', ()=>{
-    const mockOutput = {
-        error: vi.fn(),
-        log: vi.fn(),
-        warn: vi.fn()
-    };
-    const baseBuildOptions = {
-        autoUpdatesEnabled: false,
-        cliConfig: {},
-        exit: vi.fn(),
-        flags: {
-            'auto-updates': false,
-            json: false,
-            minify: false,
-            'source-maps': false,
-            stats: false,
-            yes: false
-        },
-        outDir: undefined,
-        output: mockOutput,
-        workDir: '/test/work/dir'
-    };
-    beforeEach(()=>{
-        vi.clearAllMocks();
-        // Default mocks
-        mockedReadModuleVersion.mockResolvedValue('1.0.0');
-        mockedGetAppEnvVars.mockReturnValue([]);
-        mockedGetAutoUpdatesImportMap.mockReturnValue({});
-        mockedBuildStaticFiles.mockResolvedValue({
-            chunks: []
-        });
-        mockedBuildVendorDependencies.mockResolvedValue({});
-        mockedCompareDependencyVersions.mockResolvedValue([]);
-        mockedRm.mockResolvedValue(undefined);
-    });
-    afterEach(()=>{
-        vi.restoreAllMocks();
-    });
-    it('should build app successfully with basic options', async ()=>{
-        await buildApp(baseBuildOptions);
-        expect(mockedReadModuleVersion).toHaveBeenCalledWith('/test/work/dir/dist', '@sanity/sdk-react');
-        expect(mockedBuildStaticFiles).toHaveBeenCalled();
-    });
-    it('should throw error when installedSdkVersion is not found', async ()=>{
-        mockedReadModuleVersion.mockResolvedValueOnce(undefined);
-        await expect(buildApp(baseBuildOptions)).rejects.toThrow('Failed to find installed @sanity/sdk-react version');
-    });
-    it('should throw error when auto-updates enabled but cleanSdkVersion is invalid', async ()=>{
-        // Mock an invalid version that semver.parse returns null for
-        mockedReadModuleVersion.mockResolvedValueOnce('invalid-version');
-        const options = {
-            ...baseBuildOptions,
-            autoUpdatesEnabled: true
-        };
-        await expect(buildApp(options)).rejects.toThrow('Failed to parse installed SDK version: invalid-version');
-    });
-    it('should handle auto-updates enabled with valid version', async ()=>{
-        const options = {
-            ...baseBuildOptions,
-            autoUpdatesEnabled: true
-        };
-        await buildApp(options);
-        expect(mockOutput.log).toHaveBeenCalledWith(`${logSymbols.info} Building with auto-updates enabled`);
-        expect(mockedCompareDependencyVersions).toHaveBeenCalled();
-    });
-    it('should prompt user when version differences exist and not in unattended mode', async ()=>{
-        const versionDifferences = [
-            {
-                installed: '1.0.0',
-                pkg: '@sanity/sdk-react',
-                remote: '1.1.0'
-            }
-        ];
-        mockedCompareDependencyVersions.mockResolvedValue(versionDifferences);
-        mockedConfirm.mockResolvedValue(true);
-        const options = {
-            ...baseBuildOptions,
-            autoUpdatesEnabled: true,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: false
-            }
-        };
-        await buildApp(options);
-        expect(mockedConfirm).toHaveBeenCalledWith({
-            default: false,
-            message: expect.stringContaining('different from the versions currently served')
-        });
-    });
-    it('should exit when user declines version difference confirmation', async ()=>{
-        const versionDifferences = [
-            {
-                installed: '1.0.0',
-                pkg: '@sanity/sdk-react',
-                remote: '1.1.0'
-            }
-        ];
-        mockedCompareDependencyVersions.mockResolvedValue(versionDifferences);
-        mockedConfirm.mockResolvedValue(false);
-        const options = {
-            ...baseBuildOptions,
-            autoUpdatesEnabled: true,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: false
-            }
-        };
-        await buildApp(options);
-        expect(baseBuildOptions.exit).toHaveBeenCalledWith(1);
-    });
-    it('should continue build when user confirms version difference prompt', async ()=>{
-        const versionDifferences = [
-            {
-                installed: '1.0.0',
-                pkg: '@sanity/sdk-react',
-                remote: '1.1.0'
-            }
-        ];
-        mockedCompareDependencyVersions.mockResolvedValue(versionDifferences);
-        mockedConfirm.mockResolvedValue(true);
-        const options = {
-            ...baseBuildOptions,
-            autoUpdatesEnabled: true,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: false
-            }
-        };
-        await buildApp(options);
-        expect(mockedConfirm).toHaveBeenCalledWith({
-            default: false,
-            message: expect.stringContaining('different from the versions currently served')
-        });
-        expect(baseBuildOptions.exit).not.toHaveBeenCalled();
-        expect(mockedBuildStaticFiles).toHaveBeenCalled();
-        expect(mockedBuildVendorDependencies).toHaveBeenCalled();
-    });
-    it('should skip version confirmation in unattended mode', async ()=>{
-        const versionDifferences = [
-            {
-                installed: '1.0.0',
-                pkg: '@sanity/sdk-react',
-                remote: '1.1.0'
-            }
-        ];
-        mockedCompareDependencyVersions.mockResolvedValue(versionDifferences);
-        const options = {
-            ...baseBuildOptions,
-            autoUpdatesEnabled: true,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: true
-            }
-        };
-        await buildApp(options);
-        expect(mockedConfirm).not.toHaveBeenCalled();
-    });
-    it('should log environment variables when present', async ()=>{
-        mockedGetAppEnvVars.mockReturnValue([
-            'NODE_ENV',
-            'API_URL'
-        ]);
-        await buildApp(baseBuildOptions);
-        expect(mockOutput.log).toHaveBeenCalledWith('\nIncluding the following environment variables as part of the JavaScript bundle:');
-        expect(mockOutput.log).toHaveBeenCalledWith('- NODE_ENV');
-        expect(mockOutput.log).toHaveBeenCalledWith('- API_URL');
-        expect(mockOutput.log).toHaveBeenCalledWith('');
-    });
-    it('should prompt for directory cleanup when using custom output directory in interactive mode', async ()=>{
-        mockedConfirm.mockResolvedValue(true);
-        const options = {
-            ...baseBuildOptions,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: false
-            },
-            outDir: '/custom/output/dir'
-        };
-        await buildApp(options);
-        expect(mockedConfirm).toHaveBeenCalledWith({
-            default: true,
-            message: expect.stringContaining('Do you want to delete the existing directory')
-        });
-    });
-    it('should skip cleanup when user declines directory cleanup', async ()=>{
-        mockedConfirm.mockResolvedValue(false);
-        const options = {
-            ...baseBuildOptions,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: false
-            },
-            outDir: '/custom/output/dir'
-        };
-        await buildApp(options);
-        expect(mockedRm).not.toHaveBeenCalled();
-    });
-    it('should skip cleanup prompt in unattended mode with custom output directory', async ()=>{
-        const options = {
-            ...baseBuildOptions,
-            flags: {
-                ...baseBuildOptions.flags,
-                yes: true
-            },
-            outDir: '/custom/output/dir'
-        };
-        await buildApp(options);
-        expect(mockedConfirm).not.toHaveBeenCalled();
-        expect(mockedRm).toHaveBeenCalled();
-    });
-    it('should handle CLI config with app entry', async ()=>{
-        const options = {
-            ...baseBuildOptions,
-            cliConfig: {
-                app: {
-                    entry: 'custom-entry.ts'
-                }
-            }
-        };
-        await buildApp(options);
-        expect(mockedBuildStaticFiles).toHaveBeenCalledWith(expect.objectContaining({
-            entry: 'custom-entry.ts'
-        }));
-    });
-    it('should handle CLI config with react compiler', async ()=>{
-        const reactCompilerConfig = {
-            compilationMode: 'all',
-            target: '19'
-        };
-        const options = {
-            ...baseBuildOptions,
-            cliConfig: {
-                reactCompiler: reactCompilerConfig
-            }
-        };
-        await buildApp(options);
-        expect(mockedBuildStaticFiles).toHaveBeenCalledWith(expect.objectContaining({
-            reactCompiler: reactCompilerConfig
-        }));
-    });
-    it('should handle CLI config with vite config', async ()=>{
-        const viteConfig = {
-            base: '/custom/'
-        };
-        const options = {
-            ...baseBuildOptions,
-            cliConfig: {
-                vite: viteConfig
-            }
-        };
-        await buildApp(options);
-        expect(mockedBuildStaticFiles).toHaveBeenCalledWith(expect.objectContaining({
-            vite: viteConfig
-        }));
-    });
-    it('should show stats when stats flag is enabled', async ()=>{
-        const mockBundle = {
-            chunks: [
-                {
-                    modules: [
-                        {
-                            name: 'test',
-                            renderedLength: 1000
-                        }
-                    ]
-                }
-            ]
-        };
-        mockedBuildStaticFiles.mockResolvedValue(mockBundle);
-        const options = {
-            ...baseBuildOptions,
-            flags: {
-                ...baseBuildOptions.flags,
-                stats: true
-            }
-        };
-        await buildApp(options);
-        expect(mockOutput.log).toHaveBeenCalledWith('\nLargest module files:');
-        expect(mockOutput.log).toHaveBeenCalledWith(' - test (1 kB)');
-    });
-    it('should handle build errors gracefully', async ()=>{
-        const buildError = new Error('Build failed');
-        mockedBuildStaticFiles.mockRejectedValue(buildError);
-        await buildApp(baseBuildOptions);
-        expect(mockOutput.error).toHaveBeenCalledWith('Failed to build Sanity application: Build failed', {
-            exit: 1
-        });
-    });
-    it('should handle minify flag', async ()=>{
-        const options = {
-            ...baseBuildOptions,
-            flags: {
-                ...baseBuildOptions.flags,
-                minify: true
-            }
-        };
-        await buildApp(options);
-        expect(mockedBuildStaticFiles).toHaveBeenCalledWith(expect.objectContaining({
-            minify: true
-        }));
-    });
-    it('should handle source-maps flag', async ()=>{
-        const options = {
-            ...baseBuildOptions,
-            flags: {
-                ...baseBuildOptions.flags,
-                'source-maps': true
-            }
-        };
-        await buildApp(options);
-        expect(mockedBuildStaticFiles).toHaveBeenCalledWith(expect.objectContaining({
-            sourceMap: true
-        }));
-    });
-});
-
-//# sourceMappingURL=buildApp.test.js.map