@sanity/cli 6.0.0-alpha.5 → 6.0.0-alpha.7

package/templates/shopify/schemaTypes/objects/module/imageFeaturesType.tsx

@@ -0,0 +1,51 @@
+import {ImageIcon} from '@sanity/icons'
+import pluralize from 'pluralize-esm'
+import {defineField} from 'sanity'
+
+export const imageFeaturesType = defineField({
+  name: 'images',
+  title: 'Images',
+  type: 'object',
+  icon: ImageIcon,
+  fields: [
+    defineField({
+      name: 'imageFeatures',
+      title: 'Images',
+      type: 'array',
+      of: [{type: 'imageFeature'}],
+      validation: (Rule) => Rule.required().max(2),
+    }),
+    defineField({
+      name: 'fullWidth',
+      type: 'boolean',
+      description: 'Display single image at full width (on larger breakpoints)',
+      initialValue: false,
+      hidden: ({parent}) => parent?.modules?.length > 1,
+    }),
+    defineField({
+      name: 'verticalAlign',
+      title: 'Vertical alignment',
+      type: 'string',
+      initialValue: 'top',
+      options: {
+        direction: 'horizontal',
+        layout: 'radio',
+        list: ['top', 'center', 'bottom'],
+      },
+      hidden: ({parent}) => !parent?.modules || parent?.modules?.length < 2,
+      validation: (Rule) => Rule.required(),
+    }),
+  ],
+  preview: {
+    select: {
+      images: 'imageFeatures',
+    },
+    prepare({images}) {
+      return {
+        subtitle: 'Images',
+        title: images?.length > 0 ? pluralize('image', images.length, true) : 'No images',
+        media: ImageIcon,
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/module/instagramType.ts

@@ -0,0 +1,35 @@
+import {UserIcon} from '@sanity/icons'
+import {defineField} from 'sanity'
+
+export const instagramType = defineField({
+  name: 'instagram',
+  title: 'Instagram',
+  type: 'object',
+  icon: UserIcon,
+  fields: [
+    defineField({
+      name: 'url',
+      title: 'URL',
+      type: 'string',
+      validation: (Rule) =>
+        Rule.custom((url) => {
+          const pattern = /(https?:\/\/(?:www\.)?instagram\.com\/p\/([^/?#&]+)).*/g
+          const isValid = url?.match(pattern)
+          return isValid ? true : 'Not a valid Instagram post URL'
+        }),
+    }),
+  ],
+  preview: {
+    select: {
+      url: 'url',
+    },
+    prepare(selection) {
+      const {url} = selection
+      return {
+        subtitle: 'Instagram',
+        title: url,
+        media: UserIcon,
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/module/productFeaturesType.tsx

@@ -0,0 +1,50 @@
+import {TagIcon} from '@sanity/icons'
+import pluralize from 'pluralize-esm'
+import {defineField} from 'sanity'
+
+export const productFeaturesType = defineField({
+  name: 'products',
+  title: 'Products',
+  type: 'object',
+  icon: TagIcon,
+  fields: [
+    defineField({
+      name: 'products',
+      type: 'array',
+      of: [{type: 'productReference'}],
+      validation: (Rule) => Rule.required().max(2),
+    }),
+    defineField({
+      name: 'layout',
+      type: 'string',
+      initialValue: 'card',
+      options: {
+        direction: 'horizontal',
+        layout: 'radio',
+        list: [
+          {
+            title: 'Cards (large)',
+            value: 'card',
+          },
+          {
+            title: 'Pills (small)',
+            value: 'pill',
+          },
+        ],
+      },
+      validation: (Rule) => Rule.required(),
+    }),
+  ],
+  preview: {
+    select: {
+      products: 'products',
+    },
+    prepare({products}) {
+      return {
+        subtitle: 'Products',
+        title: products.length > 0 ? pluralize('product', products.length, true) : 'No products',
+        media: TagIcon,
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/module/productReferenceType.tsx

@@ -0,0 +1,42 @@
+import {TagIcon} from '@sanity/icons'
+
+import {defineField} from 'sanity'
+
+import ShopifyDocumentStatus from '../../../components/media/ShopifyDocumentStatus'
+
+export const productReferenceType = defineField({
+  name: 'productReference',
+  title: 'Product',
+  type: 'object',
+  icon: TagIcon,
+  fields: [
+    defineField({
+      name: 'productWithVariant',
+      type: 'productWithVariant',
+      validation: (Rule) => Rule.required(),
+    }),
+  ],
+  preview: {
+    select: {
+      isDeleted: 'productWithVariant.product.store.isDeleted',
+      previewImageUrl: 'productWithVariant.product.store.previewImageUrl',
+      status: 'productWithVariant.product.store.status',
+      title: 'productWithVariant.product.store.title',
+    },
+    prepare({isDeleted, previewImageUrl, status, title}) {
+      return {
+        media: (
+          <ShopifyDocumentStatus
+            isActive={status === 'active'}
+            isDeleted={isDeleted}
+            type="product"
+            url={previewImageUrl}
+            title={title}
+          />
+        ),
+        subtitle: 'Product',
+        title,
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/seoType.ts

@@ -0,0 +1,31 @@
+import {defineField} from 'sanity'
+
+export const seoType = defineField({
+  name: 'seo',
+  title: 'SEO',
+  type: 'object',
+  group: 'seo',
+  options: {
+    collapsed: false,
+    collapsible: true,
+  },
+  fields: [
+    defineField({
+      name: 'title',
+      type: 'string',
+      validation: (Rule) =>
+        Rule.max(50).warning('Longer titles may be truncated by search engines'),
+    }),
+    defineField({
+      name: 'description',
+      type: 'text',
+      rows: 2,
+      validation: (Rule) =>
+        Rule.max(150).warning('Longer descriptions may be truncated by search engines'),
+    }),
+    defineField({
+      name: 'image',
+      type: 'image',
+    }),
+  ],
+})

package/templates/shopify/schemaTypes/objects/shopify/collectionRuleType.tsx

@@ -0,0 +1,37 @@
+import {FilterIcon} from '@sanity/icons'
+import {defineField} from 'sanity'
+
+export const collectionRuleType = defineField({
+  title: 'Collection rule',
+  name: 'collectionRule',
+  type: 'object',
+  icon: FilterIcon,
+  readOnly: true,
+  fields: [
+    defineField({
+      name: 'column',
+      type: 'string',
+    }),
+    defineField({
+      name: 'relation',
+      type: 'string',
+    }),
+    defineField({
+      name: 'condition',
+      type: 'string',
+    }),
+  ],
+  preview: {
+    select: {
+      condition: 'condition',
+      name: 'column',
+      relation: 'relation',
+    },
+    prepare({condition, name, relation}) {
+      return {
+        subtitle: `${relation} ${condition}`,
+        title: name,
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/shopify/inventoryType.ts

@@ -0,0 +1,25 @@
+import {defineField} from 'sanity'
+
+export const inventoryType = defineField({
+  name: 'inventory',
+  title: 'Inventory',
+  type: 'object',
+  options: {
+    columns: 3,
+  },
+  fields: [
+    defineField({
+      name: 'isAvailable',
+      title: 'Available',
+      type: 'boolean',
+    }),
+    defineField({
+      name: 'management',
+      type: 'string',
+    }),
+    defineField({
+      name: 'policy',
+      type: 'string',
+    }),
+  ],
+})

package/templates/shopify/schemaTypes/objects/shopify/optionType.tsx

@@ -0,0 +1,31 @@
+import {SunIcon} from '@sanity/icons'
+import {defineField} from 'sanity'
+
+export const optionType = defineField({
+  title: 'Product option',
+  name: 'option',
+  type: 'object',
+  icon: SunIcon,
+  readOnly: true,
+  fields: [
+    defineField({
+      name: 'name',
+      type: 'string',
+    }),
+    defineField({
+      name: 'values',
+      type: 'array',
+      of: [{type: 'string'}],
+    }),
+  ],
+  preview: {
+    select: {
+      name: 'name',
+    },
+    prepare({name}) {
+      return {
+        title: name,
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/shopify/placeholderStringType.ts

@@ -0,0 +1,11 @@
+import {defineType} from 'sanity'
+import PlaceholderStringInput from '../../../components/inputs/PlaceholderString'
+
+export const placeholderStringType = defineType({
+  name: 'placeholderString',
+  title: 'Title',
+  type: 'string',
+  components: {
+    input: PlaceholderStringInput,
+  },
+})

package/templates/shopify/schemaTypes/objects/shopify/priceRangeType.ts

@@ -0,0 +1,20 @@
+import {defineField} from 'sanity'
+
+export const priceRangeType = defineField({
+  name: 'priceRange',
+  title: 'Price range',
+  type: 'object',
+  options: {
+    columns: 2,
+  },
+  fields: [
+    defineField({
+      name: 'minVariantPrice',
+      type: 'number',
+    }),
+    defineField({
+      name: 'maxVariantPrice',
+      type: 'number',
+    }),
+  ],
+})

package/templates/shopify/schemaTypes/objects/shopify/productWithVariantType.tsx

@@ -0,0 +1,142 @@
+import {TagIcon} from '@sanity/icons'
+import pluralize from 'pluralize-esm'
+
+import {defineField} from 'sanity'
+
+import ShopifyDocumentStatus from '../../../components/media/ShopifyDocumentStatus'
+import {SANITY_API_VERSION} from '../../../constants'
+import {getPriceRange} from '../../../utils/getPriceRange'
+
+export const productWithVariantType = defineField({
+  name: 'productWithVariant',
+  title: 'Product with variant',
+  type: 'object',
+  icon: TagIcon,
+  fields: [
+    defineField({
+      name: 'product',
+      type: 'reference',
+      to: [{type: 'product'}],
+      weak: true,
+    }),
+    defineField({
+      name: 'variant',
+      type: 'reference',
+      to: [{type: 'productVariant'}],
+      weak: true,
+      description: 'First variant will be selected if left empty',
+      options: {
+        filter: ({parent}) => {
+          // @ts-ignore
+          const productId = parent?.product?._ref
+          const shopifyProductId = Number(productId?.replace('shopifyProduct-', ''))
+
+          if (!shopifyProductId) {
+            return {filter: '', params: {}}
+          }
+
+          // TODO: once variants are correctly marked as deleted, this could be made a little more efficient
+          // e.g. filter: 'store.productId == $shopifyProductId && !store.isDeleted',
+          return {
+            filter: `_id in *[_id == $shopifyProductId][0].store.variants[]._ref`,
+            params: {
+              shopifyProductId: productId,
+            },
+          }
+        },
+      },
+      hidden: ({parent}) => {
+        const productSelected = parent?.product
+        return !productSelected
+      },
+      validation: (Rule) =>
+        Rule.custom(async (value, {parent, getClient}) => {
+          // Selected product in adjacent `product` field
+          // @ts-ignore
+          const productId = parent?.product?._ref
+
+          // Selected product variant
+          const productVariantId = value?._ref
+
+          if (!productId || !productVariantId) {
+            return true
+          }
+
+          // If both product + product variant are specified,
+          // check to see if `product` references this product variant.
+          const result = await getClient({apiVersion: SANITY_API_VERSION}).fetch(
+            `*[_id == $productId && references($productVariantId)][0]._id`,
+            {
+              productId,
+              productVariantId,
+            },
+          )
+
+          return result ? true : 'Invalid product variant'
+        }),
+    }),
+  ],
+  preview: {
+    select: {
+      defaultVariantTitle: 'product.store.variants.0.store.title',
+      isDeleted: 'product.store.isDeleted',
+      optionCount: 'product.store.options.length',
+      previewImageUrl: 'product.store.previewImageUrl',
+      priceRange: 'product.store.priceRange',
+      status: 'product.store.status',
+      title: 'product.store.title',
+      variantCount: 'product.store.variants.length',
+      variantPreviewImageUrl: 'variant.store.previewImageUrl',
+      variantTitle: 'variant.store.title',
+    },
+    prepare(selection) {
+      const {
+        defaultVariantTitle,
+        isDeleted,
+        optionCount,
+        previewImageUrl,
+        priceRange,
+        status,
+        title,
+        variantCount,
+        variantPreviewImageUrl,
+        variantTitle,
+      } = selection
+
+      const productVariantTitle = variantTitle || defaultVariantTitle
+
+      let previewTitle = [title]
+      if (productVariantTitle) {
+        previewTitle.push(`[${productVariantTitle}]`)
+      }
+
+      let description = [
+        variantCount ? pluralize('variant', variantCount, true) : 'No variants',
+        optionCount ? pluralize('option', optionCount, true) : 'No options',
+      ]
+
+      let subtitle = getPriceRange(priceRange)
+      if (status !== 'active') {
+        subtitle = '(Unavailable in Shopify)'
+      }
+      if (isDeleted) {
+        subtitle = '(Deleted from Shopify)'
+      }
+
+      return {
+        media: (
+          <ShopifyDocumentStatus
+            isActive={status === 'active'}
+            isDeleted={isDeleted}
+            type="product"
+            url={variantPreviewImageUrl || previewImageUrl}
+            title={previewTitle.join(' ')}
+          />
+        ),
+        description: description.join(' / '),
+        subtitle,
+        title: previewTitle.join(' '),
+      }
+    },
+  },
+})

package/templates/shopify/schemaTypes/objects/shopify/proxyStringType.ts

@@ -0,0 +1,12 @@
+import {defineField} from 'sanity'
+
+import ProxyStringInput from '../../../components/inputs/ProxyString'
+
+export const proxyStringType = defineField({
+  name: 'proxyString',
+  title: 'Title',
+  type: 'string',
+  components: {
+    input: ProxyStringInput,
+  },
+})

package/templates/shopify/schemaTypes/objects/shopify/shopType.ts

@@ -0,0 +1,15 @@
+import {defineField} from 'sanity'
+
+export const shopType = defineField({
+  name: 'shop',
+  title: 'Shop',
+  type: 'object',
+  readOnly: true,
+  fields: [
+    defineField({
+      name: 'domain',
+      title: 'Domain',
+      type: 'string',
+    }),
+  ],
+})

package/templates/shopify/schemaTypes/objects/shopify/shopifyCollectionType.ts

@@ -0,0 +1,84 @@
+import {defineField} from 'sanity'
+
+export const shopifyCollectionType = defineField({
+  name: 'shopifyCollection',
+  title: 'Shopify',
+  type: 'object',
+  options: {
+    collapsed: false,
+    collapsible: true,
+  },
+  readOnly: true,
+  fieldsets: [
+    {
+      name: 'status',
+      title: 'Status',
+    },
+  ],
+  fields: [
+    defineField({
+      fieldset: 'status',
+      name: 'createdAt',
+      type: 'string',
+    }),
+    defineField({
+      fieldset: 'status',
+      name: 'updatedAt',
+      type: 'string',
+    }),
+    defineField({
+      fieldset: 'status',
+      name: 'isDeleted',
+      title: 'Deleted from Shopify?',
+      type: 'boolean',
+    }),
+    defineField({
+      name: 'title',
+      type: 'string',
+    }),
+    defineField({
+      name: 'id',
+      title: 'ID',
+      type: 'number',
+      description: 'Shopify Collection ID',
+    }),
+    defineField({
+      name: 'gid',
+      title: 'GID',
+      type: 'string',
+      description: 'Shopify Collection GID',
+    }),
+    defineField({
+      name: 'slug',
+      description: 'Shopify Collection handle',
+      type: 'slug',
+    }),
+    defineField({
+      name: 'descriptionHtml',
+      title: 'HTML Description',
+      type: 'text',
+      rows: 5,
+    }),
+    defineField({
+      name: 'imageUrl',
+      title: 'Image URL',
+      type: 'string',
+    }),
+    defineField({
+      name: 'rules',
+      type: 'array',
+      description: 'Include Shopify products that satisfy these conditions',
+      of: [{type: 'collectionRule'}],
+    }),
+    defineField({
+      name: 'disjunctive',
+      title: 'Disjunctive rules?',
+      description: 'Require any condition if true, otherwise require all conditions',
+      type: 'boolean',
+    }),
+    defineField({
+      name: 'sortOrder',
+      type: 'string',
+    }),
+  ],
+})