levrops-contracts 1.3.1 → 1.3.2

package/sanity/schema/levropsStructure/blocks/cta.ts

@@ -0,0 +1,77 @@
+import { defineType, defineField, string, text, url } from "sanity";
+
+/**
+ * CTA Block
+ * 
+ * Maps to Structure DSL block type: "cta"
+ * Sanity type: "block.cta"
+ */
+export const blockCta = defineType({
+  name: "block.cta",
+  title: "CTA Block",
+  type: "object",
+  description: "Call to action block",
+  fields: [
+    defineField({
+      name: "_key",
+      type: "string",
+      title: "Key",
+      description: "Unique key for array item (auto-generated)",
+      readOnly: true,
+    }),
+    defineField({
+      name: "headline",
+      type: string(),
+      title: "Headline",
+      validation: (Rule) => Rule.required().max(100),
+      description: "CTA headline text",
+    }),
+    defineField({
+      name: "description",
+      type: text(),
+      title: "Description",
+      description: "Supporting description text",
+    }),
+    defineField({
+      name: "buttonText",
+      type: string(),
+      title: "Button Text",
+      validation: (Rule) => Rule.required().max(50),
+      description: "CTA button text",
+    }),
+    defineField({
+      name: "buttonLink",
+      type: url(),
+      title: "Button Link",
+      validation: (Rule) => Rule.required(),
+      description: "CTA button URL",
+    }),
+    defineField({
+      name: "variant",
+      type: string(),
+      title: "Variant",
+      description: "CTA style variant",
+      options: {
+        list: [
+          { title: "Primary", value: "primary" },
+          { title: "Secondary", value: "secondary" },
+          { title: "Outline", value: "outline" },
+        ],
+      },
+      initialValue: "primary",
+    }),
+  ],
+  preview: {
+    select: {
+      headline: "headline",
+      buttonText: "buttonText",
+    },
+    prepare({ headline, buttonText }) {
+      return {
+        title: headline || "CTA Block",
+        subtitle: buttonText || "No button text",
+      };
+    },
+  },
+});
+

package/sanity/schema/levropsStructure/blocks/editorialGrid.ts

@@ -0,0 +1,66 @@
+import { defineType, defineField, string, array, reference } from "sanity";
+
+/**
+ * Editorial Grid Block
+ * 
+ * Maps to Structure DSL block type: "editorial_grid"
+ * Sanity type: "block.editorialGrid"
+ */
+export const blockEditorialGrid = defineType({
+  name: "block.editorialGrid",
+  title: "Editorial Grid Block",
+  type: "object",
+  description: "Grid of editorial content",
+  fields: [
+    defineField({
+      name: "_key",
+      type: "string",
+      title: "Key",
+      description: "Unique key for array item (auto-generated)",
+      readOnly: true,
+    }),
+    defineField({
+      name: "title",
+      type: string(),
+      title: "Title",
+      validation: (Rule) => Rule.required().max(200),
+      description: "Grid section title",
+    }),
+    defineField({
+      name: "items",
+      type: array({
+        of: [
+          {
+            type: "reference",
+            to: [{ type: "blog-post" }],
+          },
+        ],
+      }),
+      title: "Items",
+      validation: (Rule) => Rule.min(1),
+      description: "Editorial content items (blog posts, articles, etc.)",
+    }),
+    defineField({
+      name: "columns",
+      type: "number",
+      title: "Columns",
+      description: "Number of columns in grid",
+      validation: (Rule) => Rule.min(1).max(4).integer(),
+      initialValue: 3,
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      itemCount: "items.length",
+      columns: "columns",
+    },
+    prepare({ title, itemCount, columns }) {
+      return {
+        title: title || "Editorial Grid Block",
+        subtitle: `${itemCount || 0} item(s) • ${columns || 3} column(s)`,
+      };
+    },
+  },
+});
+

package/sanity/schema/levropsStructure/blocks/hero.ts

@@ -0,0 +1,71 @@
+import { defineType, defineField, string, text, url, image } from "sanity";
+
+/**
+ * Hero Block
+ * 
+ * Maps to Structure DSL block type: "hero"
+ * Sanity type: "block.hero"
+ * 
+ * Fields map directly from Structure DSL block definition.
+ * Constraints from Structure DSL are enforced via validation rules.
+ */
+export const blockHero = defineType({
+  name: "block.hero",
+  title: "Hero Block",
+  type: "object",
+  description: "Large headline with supporting text and CTA",
+  fields: [
+    defineField({
+      name: "_key",
+      type: "string",
+      title: "Key",
+      description: "Unique key for array item (auto-generated)",
+      readOnly: true,
+    }),
+    defineField({
+      name: "headline",
+      type: string(),
+      title: "Headline",
+      validation: (Rule) => Rule.required().max(100),
+      description: "Main headline text",
+    }),
+    defineField({
+      name: "subheadline",
+      type: text(),
+      title: "Subheadline",
+      description: "Supporting text below headline",
+    }),
+    defineField({
+      name: "backgroundImage",
+      type: image(),
+      title: "Background Image",
+      validation: (Rule) => Rule.required(),
+      description: "Hero background image",
+    }),
+    defineField({
+      name: "ctaText",
+      type: string(),
+      title: "CTA Button Text",
+      description: "Call-to-action button text",
+    }),
+    defineField({
+      name: "ctaLink",
+      type: url(),
+      title: "CTA Link",
+      description: "Call-to-action button URL",
+    }),
+  ],
+  preview: {
+    select: {
+      headline: "headline",
+      subheadline: "subheadline",
+    },
+    prepare({ headline, subheadline }) {
+      return {
+        title: headline || "Hero Block",
+        subtitle: subheadline || "No subheadline",
+      };
+    },
+  },
+});
+

package/sanity/schema/levropsStructure/blocks/product.ts

@@ -0,0 +1,69 @@
+import { defineType, defineField, string, text, array, image, reference } from "sanity";
+
+/**
+ * Product Block
+ * 
+ * Maps to Structure DSL block type: "product"
+ * Sanity type: "block.product"
+ */
+export const blockProduct = defineType({
+  name: "block.product",
+  title: "Product Block",
+  type: "object",
+  description: "Product showcase block",
+  fields: [
+    defineField({
+      name: "_key",
+      type: "string",
+      title: "Key",
+      description: "Unique key for array item (auto-generated)",
+      readOnly: true,
+    }),
+    defineField({
+      name: "title",
+      type: string(),
+      title: "Title",
+      validation: (Rule) => Rule.required().max(200),
+      description: "Product block title",
+    }),
+    defineField({
+      name: "description",
+      type: text(),
+      title: "Description",
+      description: "Product block description",
+    }),
+    defineField({
+      name: "products",
+      type: array({
+        of: [
+          {
+            type: "reference",
+            to: [{ type: "product" }],
+          },
+        ],
+      }),
+      title: "Products",
+      validation: (Rule) => Rule.min(1),
+      description: "Referenced products to showcase",
+    }),
+    defineField({
+      name: "image",
+      type: image(),
+      title: "Image",
+      description: "Optional product block image",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      productCount: "products.length",
+    },
+    prepare({ title, productCount }) {
+      return {
+        title: title || "Product Block",
+        subtitle: `${productCount || 0} product(s)`,
+      };
+    },
+  },
+});
+

package/sanity/schema/levropsStructure/blocks/ritual.ts

@@ -0,0 +1,59 @@
+import { defineType, defineField, string, array, reference } from "sanity";
+
+/**
+ * Ritual Block
+ * 
+ * Maps to Structure DSL block type: "ritual"
+ * Sanity type: "block.ritual"
+ * 
+ * Optional block type for ritual/ceremony content.
+ */
+export const blockRitual = defineType({
+  name: "block.ritual",
+  title: "Ritual Block",
+  type: "object",
+  description: "Ritual or ceremony content block",
+  fields: [
+    defineField({
+      name: "_key",
+      type: "string",
+      title: "Key",
+      description: "Unique key for array item (auto-generated)",
+      readOnly: true,
+    }),
+    defineField({
+      name: "title",
+      type: string(),
+      title: "Title",
+      validation: (Rule) => Rule.required().max(200),
+      description: "Ritual block title",
+    }),
+    defineField({
+      name: "rituals",
+      type: array({
+        of: [
+          {
+            type: "reference",
+            to: [{ type: "ritual" }],
+          },
+        ],
+      }),
+      title: "Rituals",
+      validation: (Rule) => Rule.min(1),
+      description: "Referenced ritual documents",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      ritualCount: "rituals.length",
+    },
+    prepare({ title, ritualCount }) {
+      return {
+        title: title || "Ritual Block",
+        subtitle: `${ritualCount || 0} ritual(s)`,
+      };
+    },
+  },
+});
+

package/sanity/schema/levropsStructure/blocks/story.ts

@@ -0,0 +1,57 @@
+import { defineType, defineField, string, array, image } from "sanity";
+
+/**
+ * Story Block
+ * 
+ * Maps to Structure DSL block type: "story"
+ * Sanity type: "block.story"
+ */
+export const blockStory = defineType({
+  name: "block.story",
+  title: "Story Block",
+  type: "object",
+  description: "Narrative content block",
+  fields: [
+    defineField({
+      name: "_key",
+      type: "string",
+      title: "Key",
+      description: "Unique key for array item (auto-generated)",
+      readOnly: true,
+    }),
+    defineField({
+      name: "title",
+      type: string(),
+      title: "Title",
+      validation: (Rule) => Rule.required().max(200),
+      description: "Story section title",
+    }),
+    defineField({
+      name: "content",
+      type: array({
+        of: [{ type: "block" }],
+      }),
+      title: "Content",
+      validation: (Rule) => Rule.required(),
+      description: "Story content (portable text)",
+    }),
+    defineField({
+      name: "image",
+      type: image(),
+      title: "Image",
+      description: "Optional story image",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+    },
+    prepare({ title }) {
+      return {
+        title: title || "Story Block",
+        subtitle: "Narrative content",
+      };
+    },
+  },
+});
+

package/sanity/schema/levropsStructure/index.ts

@@ -0,0 +1,21 @@
+/**
+ * LevrOps Structure Schema
+ * 
+ * This schema defines the Sanity document and object types for Expression Studio Structure.
+ * 
+ * Mapping:
+ * - Page templates → page document with pageType discriminant
+ * - Block types → block.* object types
+ * 
+ * This schema is deterministic and stable across tenants/properties.
+ * Tenant-specific configuration is stored in LevrOps backend, not in Sanity schema.
+ */
+
+export { page } from './page';
+export { blockHero } from './blocks/hero';
+export { blockStory } from './blocks/story';
+export { blockProduct } from './blocks/product';
+export { blockEditorialGrid } from './blocks/editorialGrid';
+export { blockCta } from './blocks/cta';
+export { blockRitual } from './blocks/ritual';
+

package/sanity/schema/levropsStructure/page.ts

@@ -0,0 +1,118 @@
+import { defineType, defineField, string, slug, array } from "sanity";
+
+/**
+ * Page Document
+ * 
+ * Single document type for all page templates, discriminated by pageType.
+ * 
+ * Rationale for single document type:
+ * - More flexible: can add new page types without schema changes
+ * - Simpler maintenance: one document type to manage
+ * - Better tenant isolation: shared schema, tenant-specific config in LevrOps
+ * - Aligns with Sanity's pattern of using discriminators
+ * 
+ * Mapping:
+ * - pageType enum → page template IDs from Structure DSL
+ * - blocks array → ordered composition of block.* object types
+ */
+export const page = defineType({
+  name: "page",
+  title: "Page",
+  type: "document",
+  description: "A page composed of ordered blocks, discriminated by pageType",
+  fields: [
+    defineField({
+      name: "title",
+      type: string(),
+      title: "Title",
+      validation: (Rule) => Rule.required().max(200),
+      description: "Page title",
+    }),
+    defineField({
+      name: "slug",
+      type: slug({
+        source: "title",
+      }),
+      title: "Slug",
+      validation: (Rule) => Rule.required(),
+      description: "URL-friendly identifier",
+    }),
+    defineField({
+      name: "pageType",
+      type: string(),
+      title: "Page Type",
+      validation: (Rule) => Rule.required(),
+      description: "Template type (maps to Structure DSL page template ID)",
+      options: {
+        list: [
+          { title: "Homepage", value: "homepage" },
+          { title: "Product Page", value: "product_page" },
+          { title: "Editorial Page", value: "editorial_page" },
+        ],
+      },
+    }),
+    defineField({
+      name: "blocks",
+      type: array({
+        of: [
+          { type: "block.hero" },
+          { type: "block.story" },
+          { type: "block.product" },
+          { type: "block.editorialGrid" },
+          { type: "block.cta" },
+          { type: "block.ritual" },
+        ],
+      }),
+      title: "Blocks",
+      description: "Ordered composition of content blocks",
+      validation: (Rule) => Rule.required().min(1),
+    }),
+    defineField({
+      name: "metadata",
+      type: "object",
+      title: "Metadata",
+      description: "Hidden metadata fields for LevrOps integration",
+      fields: [
+        defineField({
+          name: "structureId",
+          type: string(),
+          title: "Structure ID",
+          description: "Reference to Structure DSL block/template IDs",
+          hidden: true,
+        }),
+        defineField({
+          name: "tenantId",
+          type: string(),
+          title: "Tenant ID",
+          description: "Tenant identifier for isolation",
+          hidden: true,
+        }),
+        defineField({
+          name: "propertyId",
+          type: string(),
+          title: "Property ID",
+          description: "Property identifier for isolation",
+          hidden: true,
+        }),
+      ],
+      options: {
+        collapsible: true,
+        collapsed: true,
+      },
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      pageType: "pageType",
+      slug: "slug.current",
+    },
+    prepare({ title, pageType, slug }) {
+      return {
+        title: title || "Untitled Page",
+        subtitle: `${pageType || "unknown"} • /${slug || ""}`,
+      };
+    },
+  },
+});
+