@sanity/schema-lint 0.0.1 → 0.0.3

package/dist/testing.d.cts

@@ -0,0 +1,81 @@
+import { S as SchemaType, a as SchemaRule } from './types-C3OVyCP6.cjs';
+import '@sanity/lint-core';
+
+/**
+ * A valid test case - schema that should produce no findings
+ */
+interface ValidSchemaTestCase {
+    /** The schema to test */
+    schema: SchemaType;
+    /** Optional name for the test */
+    name?: string;
+}
+/**
+ * Expected error in an invalid test case
+ */
+interface ExpectedSchemaError {
+    /** Expected rule ID (defaults to the rule being tested) */
+    ruleId?: string;
+    /** Expected message (string for exact match, RegExp for pattern) */
+    message?: string | RegExp;
+    /** Expected severity */
+    severity?: 'error' | 'warning' | 'info';
+}
+/**
+ * An invalid test case - schema that should produce findings
+ */
+interface InvalidSchemaTestCase {
+    /** The schema to test */
+    schema: SchemaType;
+    /** Optional name for the test */
+    name?: string;
+    /** Expected errors */
+    errors: ExpectedSchemaError[];
+}
+/**
+ * Test suite for a schema rule
+ */
+interface SchemaRuleTests {
+    /** Schemas that should produce no findings */
+    valid: (SchemaType | ValidSchemaTestCase)[];
+    /** Schemas that should produce findings */
+    invalid: InvalidSchemaTestCase[];
+}
+/**
+ * Helper to create a minimal valid schema for testing
+ */
+declare function createSchema(overrides?: Partial<SchemaType>): SchemaType;
+/**
+ * Test utility for schema lint rules, inspired by ESLint's RuleTester
+ *
+ * @example
+ * ```typescript
+ * import { SchemaRuleTester, createSchema } from '@sanity/schema-lint/testing'
+ * import { missingIcon } from '../missing-icon'
+ *
+ * const tester = new SchemaRuleTester()
+ *
+ * tester.run('missing-icon', missingIcon, {
+ *   valid: [
+ *     createSchema({ hasIcon: true }),
+ *   ],
+ *   invalid: [
+ *     {
+ *       schema: createSchema({ hasIcon: false }),
+ *       errors: [{ ruleId: 'missing-icon' }]
+ *     }
+ *   ]
+ * })
+ * ```
+ */
+declare class SchemaRuleTester {
+    /**
+     * Run tests for a schema rule
+     * @param ruleName - Name for the test suite
+     * @param rule - The rule to test
+     * @param tests - Valid and invalid test cases
+     */
+    run(ruleName: string, rule: SchemaRule, tests: SchemaRuleTests): void;
+}
+
+export { type ExpectedSchemaError, type InvalidSchemaTestCase, SchemaRuleTester, type SchemaRuleTests, type ValidSchemaTestCase, createSchema };

package/dist/types-C3OVyCP6.d.cts

@@ -0,0 +1,121 @@
+import { SourceSpan, Severity, Category, Finding } from '@sanity/lint-core';
+
+/**
+ * Represents a field in a Sanity schema
+ */
+interface SchemaField {
+    /** Field name */
+    name: string;
+    /** Field type (string, number, reference, array, etc.) */
+    type: string;
+    /** Human-readable title */
+    title?: string;
+    /** Field description */
+    description?: string;
+    /** Whether the field has validation rules */
+    hasValidation?: boolean;
+    /** Whether the field is deprecated */
+    deprecated?: boolean | string;
+    /** Whether the field is hidden */
+    hidden?: boolean;
+    /** Whether the field is readOnly */
+    readOnly?: boolean;
+    /** Field options (e.g., source for slug, list for string) */
+    options?: {
+        source?: string;
+        list?: unknown[];
+        hotspot?: boolean;
+        layout?: string;
+        [key: string]: unknown;
+    };
+    /** For array fields, the types allowed in the array */
+    of?: SchemaField[];
+    /** For reference fields, the types that can be referenced */
+    to?: {
+        type: string;
+    }[];
+    /** Location in source for error reporting */
+    span?: SourceSpan;
+}
+/**
+ * Represents a Sanity schema type definition
+ */
+interface SchemaType {
+    /** Type name (e.g., 'post', 'author') */
+    name: string;
+    /** Schema type (document, object, array, etc.) */
+    type: string;
+    /** Human-readable title */
+    title?: string;
+    /** Type description */
+    description?: string;
+    /** Whether the type has an icon defined */
+    hasIcon?: boolean;
+    /** Whether the type has a preview configuration */
+    hasPreview?: boolean;
+    /** Fields defined on this type */
+    fields?: SchemaField[];
+    /** Groups for organizing fields in the Studio */
+    groups?: {
+        name: string;
+        title?: string;
+    }[];
+    /** Location in source for error reporting */
+    span?: SourceSpan;
+    /** Whether defineType() was used */
+    usesDefineType?: boolean;
+    /** Whether defineField() was used for all fields */
+    usesDefineField?: boolean;
+}
+/**
+ * Context provided to schema rules during checking
+ */
+interface SchemaRuleContext {
+    /** The file path being linted */
+    filePath: string;
+    /** Report a finding */
+    report: (finding: Omit<Finding, 'ruleId'>) => void;
+}
+/**
+ * A schema lint rule definition
+ */
+interface SchemaRule {
+    /** Unique identifier (kebab-case) */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description of what the rule checks */
+    description: string;
+    /** Default severity */
+    severity: Severity;
+    /** Rule category */
+    category: Category;
+    /** Rule IDs that this rule supersedes */
+    supersedes?: string[];
+    /**
+     * Check the schema for violations
+     * @param schema - The parsed schema type
+     * @param context - Context with file info and report function
+     */
+    check: (schema: SchemaType, context: SchemaRuleContext) => void;
+}
+/**
+ * Configuration for a schema rule
+ */
+interface SchemaRuleConfig {
+    /** Whether the rule is enabled */
+    enabled?: boolean;
+    /** Override severity */
+    severity?: Severity;
+    /** Rule-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Schema linter configuration
+ */
+interface SchemaLinterConfig {
+    /** Rule configurations keyed by rule ID */
+    rules?: Record<string, SchemaRuleConfig | boolean>;
+}
+
+export type { SchemaType as S, SchemaRule as a, SchemaLinterConfig as b, SchemaField as c, SchemaRuleContext as d, SchemaRuleConfig as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/schema-lint",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Schema linting engine and rules for Sanity Lint",
   "author": "Sanity.io <hello@sanity.io>",
   "license": "MIT",
@@ -13,20 +13,22 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./testing": {
       "types": "./dist/testing.d.ts",
-      "import": "./dist/testing.js"
+      "import": "./dist/testing.js",
+      "require": "./dist/testing.cjs"
     }
   },
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@sanity/lint-core": "0.0.1"
+    "@sanity/lint-core": "0.0.3"
   },
   "devDependencies": {
     "tsup": "^8.3.5",