@imjp/writenex-astro 1.3.6 → 1.5.0

package/src/config/schema.ts

@@ -10,9 +10,6 @@
 import { z } from "zod";
 import type { WritenexConfig } from "@/types";
 
-/**
- * Schema for field type definitions
- */
 const fieldTypeSchema = z.enum([
   "string",
   "number",
@@ -21,41 +18,124 @@ const fieldTypeSchema = z.enum([
   "array",
   "image",
   "object",
+  "file",
+  "blocks",
+  "relationship",
+  "markdoc",
+  "mdx",
+  "child",
+  "slug",
+  "url",
+  "integer",
+  "select",
+  "multiselect",
+  "datetime",
+  "cloud-image",
+  "path-reference",
+  "conditional",
+  "empty",
+  "empty-content",
+  "empty-document",
+  "ignored",
+  "checkbox",
 ]);
 
-/**
- * Schema for individual schema field definition
- */
-const schemaFieldSchema = z.object({
-  type: fieldTypeSchema,
-  required: z.boolean().optional(),
-  default: z.unknown().optional(),
-  items: z.string().optional(),
-  description: z.string().optional(),
-});
+const validationSchema = z
+  .object({
+    isRequired: z.boolean().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional(),
+    patternDescription: z.string().optional(),
+  })
+  .optional();
+
+type SchemaFieldInput = {
+  type: z.infer<typeof fieldTypeSchema>;
+  required?: boolean;
+  default?: unknown;
+  items?: string;
+  description?: string;
+  label?: string;
+  options?: string[];
+  directory?: string;
+  publicPath?: string;
+  validation?: z.infer<typeof validationSchema>;
+  fields?: Record<string, SchemaFieldInput>;
+  itemField?: SchemaFieldInput;
+  blockTypes?: Record<string, SchemaFieldInput>;
+  collection?: string;
+  multiline?: boolean;
+  format?: string;
+  itemLabel?: string;
+  matchField?: string;
+  matchValue?: unknown;
+  showField?: SchemaFieldInput;
+  accept?: string;
+  allowExternal?: boolean;
+  inline?: boolean;
+};
+
+function createSchemaFieldSchema(): z.ZodType<SchemaFieldInput> {
+  let schemaFieldSchema: z.ZodType<SchemaFieldInput>;
+
+  const baseFields = {
+    type: fieldTypeSchema,
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    items: z.string().optional(),
+    description: z.string().optional(),
+    label: z.string().optional(),
+    options: z.array(z.string()).optional(),
+    directory: z.string().optional(),
+    publicPath: z.string().optional(),
+    validation: validationSchema,
+    collection: z.string().optional(),
+    multiline: z.boolean().optional(),
+    format: z.string().optional(),
+    itemLabel: z.string().optional(),
+    matchField: z.string().optional(),
+    matchValue: z.unknown().optional(),
+    accept: z.string().optional(),
+    allowExternal: z.boolean().optional(),
+    inline: z.boolean().optional(),
+  };
+
+  schemaFieldSchema = z.object({
+    ...baseFields,
+    fields: z
+      .record(
+        z.string(),
+        z.lazy(() => schemaFieldSchema)
+      )
+      .optional(),
+    itemField: z.lazy(() => schemaFieldSchema).optional(),
+    blockTypes: z
+      .record(
+        z.string(),
+        z.lazy(() => schemaFieldSchema)
+      )
+      .optional(),
+    showField: z.lazy(() => schemaFieldSchema).optional(),
+  });
+
+  return schemaFieldSchema;
+}
+
+const schemaFieldSchema = createSchemaFieldSchema();
 
-/**
- * Schema for collection schema (record of field definitions)
- */
 const collectionSchemaSchema = z.record(z.string(), schemaFieldSchema);
 
-/**
- * Schema for image strategy
- */
 const imageStrategySchema = z.enum(["colocated", "public", "custom"]);
 
-/**
- * Schema for image configuration
- */
 const imageConfigSchema = z.object({
   strategy: imageStrategySchema,
   publicPath: z.string().optional(),
   storagePath: z.string().optional(),
 });
 
-/**
- * Schema for collection configuration
- */
 const collectionConfigSchema = z.object({
   name: z.string().min(1, "Collection name is required"),
   path: z.string().min(1, "Collection path is required"),
@@ -65,77 +145,44 @@ const collectionConfigSchema = z.object({
   images: imageConfigSchema.optional(),
 });
 
-/**
- * Schema for discovery configuration
- */
+const singletonConfigSchema = z.object({
+  name: z.string().min(1, "Singleton name is required"),
+  path: z.string().min(1, "Singleton path is required"),
+  previewUrl: z.string().optional(),
+  schema: collectionSchemaSchema.optional(),
+  images: imageConfigSchema.optional(),
+});
+
 const discoveryConfigSchema = z.object({
   enabled: z.boolean(),
   ignore: z.array(z.string()).optional(),
 });
 
-/**
- * Schema for editor configuration
- */
 const editorConfigSchema = z.object({
   autosave: z.boolean().optional(),
   autosaveInterval: z.number().positive().optional(),
 });
 
-/**
- * Schema for version history configuration
- */
 const versionHistoryConfigSchema = z.object({
   enabled: z.boolean().optional(),
   maxVersions: z.number().int().positive().optional(),
   storagePath: z.string().optional(),
 });
 
-/**
- * Main Writenex configuration schema
- */
 export const writenexConfigSchema = z.object({
   collections: z.array(collectionConfigSchema).optional(),
+  singletons: z.array(singletonConfigSchema).optional(),
   images: imageConfigSchema.optional(),
   editor: editorConfigSchema.optional(),
   discovery: discoveryConfigSchema.optional(),
   versionHistory: versionHistoryConfigSchema.optional(),
 });
 
-/**
- * Schema for integration options
- */
 export const writenexOptionsSchema = z.object({
   allowProduction: z.boolean().optional(),
 });
 
-/**
- * Helper function for defining type-safe Writenex configuration.
- *
- * This function provides IDE autocompletion and type checking for
- * the configuration object. It's the recommended way to create
- * a writenex.config.ts file.
- *
- * @param config - The Writenex configuration object
- * @returns The same configuration object (identity function for type safety)
- *
- * @example
- * ```typescript
- * // writenex.config.ts
- * import { defineConfig } from '@writenex/astro';
- *
- * export default defineConfig({
- *   collections: [
- *     {
- *       name: 'blog',
- *       path: 'src/content/blog',
- *       filePattern: '{slug}.md',
- *     },
- *   ],
- * });
- * ```
- */
 export function defineConfig(config: WritenexConfig): WritenexConfig {
-  // Validate the configuration
   const result = writenexConfigSchema.safeParse(config);
 
   if (!result.success) {
@@ -148,12 +195,6 @@ export function defineConfig(config: WritenexConfig): WritenexConfig {
   return config;
 }
 
-/**
- * Validate a Writenex configuration object
- *
- * @param config - The configuration to validate
- * @returns Validation result with success status and parsed data or errors
- */
 export function validateConfig(
   config: unknown
 ):

package/src/discovery/schema.ts

@@ -60,6 +60,69 @@ const IMAGE_EXTENSIONS = [
   ".svg",
 ];
 
+/**
+ * URL pattern detection
+ */
+const URL_PATTERN = /^https?:\/\//;
+
+/**
+ * Slug pattern detection (lowercase, hyphenated)
+ */
+const SLUG_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+
+/**
+ * Datetime pattern detection (ISO datetime)
+ */
+const DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+
+/**
+ * Check if a string looks like a URL
+ */
+function isUrlValue(value: unknown): boolean {
+  if (typeof value !== "string") return false;
+  return URL_PATTERN.test(value);
+}
+
+/**
+ * Check if a string looks like a slug
+ */
+function isSlugValue(value: unknown): boolean {
+  if (typeof value !== "string") return false;
+  if (value.length < 2 || value.length > 100) return false;
+  return SLUG_PATTERN.test(value);
+}
+
+/**
+ * Check if a string looks like a datetime
+ */
+function isDatetimeValue(value: unknown): boolean {
+  if (typeof value !== "string") return false;
+  return DATETIME_PATTERN.test(value);
+}
+
+/**
+ * Check if a string looks like a file path (non-image)
+ */
+function isFilePath(value: unknown): boolean {
+  if (typeof value !== "string") return false;
+  if (isImagePath(value)) return false;
+  return /\.\w{2,5}$/.test(value);
+}
+
+/**
+ * Check if an array looks like a multiselect (array of strings from a small set)
+ */
+function isMultiselectArray(values: unknown[]): boolean {
+  if (values.length === 0) return false;
+  const allStrings = values.every((v) => typeof v === "string" && v.length > 0);
+  if (!allStrings) return false;
+  const uniqueValues = [...new Set(values)];
+  return (
+    uniqueValues.length <= ENUM_MAX_VALUES &&
+    values.length > uniqueValues.length
+  );
+}
+
 /**
  * Field analysis data collected from samples
  */
@@ -74,6 +137,18 @@ interface FieldAnalysis {
   hasImagePaths: boolean;
   /** Whether values look like dates */
   hasDateValues: boolean;
+  /** Whether values look like URLs */
+  hasUrlValues: boolean;
+  /** Whether values look like slugs */
+  hasSlugValues: boolean;
+  /** Whether values look like datetimes */
+  hasDatetimeValues: boolean;
+  /** Whether values look like file paths */
+  hasFilePaths: boolean;
+  /** Whether all number values are integers */
+  allIntegers: boolean;
+  /** Whether array looks like multiselect */
+  isMultiselect: boolean;
   /** For arrays, analysis of item types */
   arrayItemTypes: Set<string>;
 }
@@ -153,9 +228,29 @@ function inferFieldType(analysis: FieldAnalysis): FieldType {
   // If it has image paths, it's an image field
   if (analysis.hasImagePaths) return "image";
 
+  // If it has datetime values, it's a datetime field
+  if (analysis.hasDatetimeValues) return "datetime";
+
   // If it has date values, it's a date field
   if (analysis.hasDateValues) return "date";
 
+  // If it has file paths, it's a file field
+  if (analysis.hasFilePaths) return "file";
+
+  // If it has URL values, it's a url field
+  if (analysis.hasUrlValues) return "url";
+
+  // If it has slug values and is a single string type
+  if (analysis.hasSlugValues && analysis.types.size === 1) {
+    const typesArr = [...analysis.types];
+    if (typesArr.length === 1 && typesArr[0] === "string") {
+      return "slug";
+    }
+  }
+
+  // Check for multiselect arrays
+  if (analysis.isMultiselect) return "multiselect";
+
   // Check detected types (excluding null)
   const nonNullTypes = new Set([...analysis.types].filter((t) => t !== "null"));
 
@@ -166,7 +261,7 @@ function inferFieldType(analysis: FieldAnalysis): FieldType {
       case "boolean":
         return "boolean";
       case "number":
-        return "number";
+        return analysis.allIntegers ? "integer" : "number";
       case "array":
         return "array";
       case "object":
@@ -290,6 +385,12 @@ export async function detectSchema(
           values: [],
           hasImagePaths: false,
           hasDateValues: false,
+          hasUrlValues: false,
+          hasSlugValues: false,
+          hasDatetimeValues: false,
+          hasFilePaths: false,
+          allIntegers: true,
+          isMultiselect: false,
           arrayItemTypes: new Set(),
         };
         fieldAnalyses.set(fieldName, analysis);
@@ -307,12 +408,30 @@ export async function detectSchema(
       if (isDateValue(value)) {
         analysis.hasDateValues = true;
       }
+      if (isUrlValue(value)) {
+        analysis.hasUrlValues = true;
+      }
+      if (isSlugValue(value)) {
+        analysis.hasSlugValues = true;
+      }
+      if (isDatetimeValue(value)) {
+        analysis.hasDatetimeValues = true;
+      }
+      if (isFilePath(value)) {
+        analysis.hasFilePaths = true;
+      }
+      if (typeof value === "number" && !Number.isInteger(value)) {
+        analysis.allIntegers = false;
+      }
 
       // Analyze array items
       if (Array.isArray(value)) {
         for (const item of value) {
           analysis.arrayItemTypes.add(detectValueType(item));
         }
+        if (isMultiselectArray(value)) {
+          analysis.isMultiselect = true;
+        }
       }
     }
   }

package/src/fields/collection.ts

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Collection and Singleton schema helpers
+ *
+ * These helpers provide a typed way to define collection and singleton
+ * schemas using the fields builder API. They convert FieldDefinition
+ * objects to internal SchemaField format.
+ *
+ * @module @writenex/astro/fields/collection
+ */
+
+import type { CollectionConfig, ImageConfig } from "@/types";
+import { resolveFieldDefinition } from "./resolve";
+import type { FieldDefinition } from "./types";
+
+export interface CollectionSchemaConfig {
+  name: string;
+  path: string;
+  filePattern?: string;
+  previewUrl?: string;
+  schema: Record<string, FieldDefinition>;
+  images?: ImageConfig;
+}
+
+export interface SingletonSchemaConfig {
+  name: string;
+  path: string;
+  previewUrl?: string;
+  schema: Record<string, FieldDefinition>;
+  images?: ImageConfig;
+}
+
+export function collection(config: CollectionSchemaConfig): CollectionConfig {
+  const schema: Record<string, import("@/types").SchemaField> = {};
+  for (const [key, fieldDef] of Object.entries(config.schema)) {
+    schema[key] = resolveFieldDefinition(fieldDef);
+  }
+
+  return {
+    name: config.name,
+    path: config.path,
+    filePattern: config.filePattern,
+    previewUrl: config.previewUrl,
+    schema,
+    images: config.images,
+  };
+}
+
+export function singleton(config: SingletonSchemaConfig): {
+  name: string;
+  path: string;
+  previewUrl?: string;
+  schema: Record<string, import("@/types").SchemaField>;
+  images?: ImageConfig;
+} {
+  const schema: Record<string, import("@/types").SchemaField> = {};
+  for (const [key, fieldDef] of Object.entries(config.schema)) {
+    schema[key] = resolveFieldDefinition(fieldDef);
+  }
+
+  return {
+    name: config.name,
+    path: config.path,
+    previewUrl: config.previewUrl,
+    schema,
+    images: config.images,
+  };
+}

package/src/fields/fields.ts

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Fields builder API for @writenex/astro
+ *
+ * This module provides a TypeScript-first builder pattern for defining
+ * content schema fields. Each field type is a method on the `fields` object.
+ *
+ * @module @writenex/astro/fields/fields
+ */
+
+import type {
+  ArrayFieldConfig,
+  BaseFieldConfig,
+  BlocksFieldConfig,
+  CheckboxFieldConfig,
+  ChildFieldConfig,
+  CloudImageFieldConfig,
+  ConditionalFieldConfig,
+  DateFieldConfig,
+  DatetimeFieldConfig,
+  FieldDefinition,
+  FileFieldConfig,
+  ImageFieldConfig,
+  IntegerFieldConfig,
+  MarkdocFieldConfig,
+  MdxFieldConfig,
+  MultiselectFieldConfig,
+  NumberFieldConfig,
+  ObjectFieldConfig,
+  PathReferenceFieldConfig,
+  RelationshipFieldConfig,
+  SelectFieldConfig,
+  SlugFieldConfig,
+  TextFieldConfig,
+  UrlFieldConfig,
+} from "./types";
+
+function createField<K extends FieldDefinition["fieldKind"]>(
+  fieldKind: K,
+  config: Omit<Extract<FieldDefinition, { fieldKind: K }>, "fieldKind">
+): Extract<FieldDefinition, { fieldKind: K }> {
+  return { fieldKind, ...config } as Extract<FieldDefinition, { fieldKind: K }>;
+}
+
+export const fields = {
+  text(config: TextFieldConfig = {}): FieldDefinition {
+    return createField("text", config);
+  },
+
+  slug(config: SlugFieldConfig = {}): FieldDefinition {
+    return createField("slug", config);
+  },
+
+  url(config: UrlFieldConfig = {}): FieldDefinition {
+    return createField("url", config);
+  },
+
+  number(config: NumberFieldConfig = {}): FieldDefinition {
+    return createField("number", config);
+  },
+
+  integer(config: IntegerFieldConfig = {}): FieldDefinition {
+    return createField("integer", config);
+  },
+
+  select(config: SelectFieldConfig): FieldDefinition {
+    return createField("select", config);
+  },
+
+  multiselect(config: MultiselectFieldConfig): FieldDefinition {
+    return createField("multiselect", config);
+  },
+
+  checkbox(config: CheckboxFieldConfig = {}): FieldDefinition {
+    return createField("checkbox", config);
+  },
+
+  date(config: DateFieldConfig = {}): FieldDefinition {
+    return createField("date", config);
+  },
+
+  datetime(config: DatetimeFieldConfig = {}): FieldDefinition {
+    return createField("datetime", config);
+  },
+
+  image(config: ImageFieldConfig = {}): FieldDefinition {
+    return createField("image", config);
+  },
+
+  file(config: FileFieldConfig = {}): FieldDefinition {
+    return createField("file", config);
+  },
+
+  object(config: ObjectFieldConfig): FieldDefinition {
+    return createField("object", config);
+  },
+
+  array(config: ArrayFieldConfig): FieldDefinition {
+    return createField("array", config);
+  },
+
+  blocks(config: BlocksFieldConfig): FieldDefinition {
+    return createField("blocks", config);
+  },
+
+  relationship(config: RelationshipFieldConfig): FieldDefinition {
+    return createField("relationship", config);
+  },
+
+  pathReference(config: PathReferenceFieldConfig = {}): FieldDefinition {
+    return createField("path-reference", config);
+  },
+
+  markdoc(config: MarkdocFieldConfig = {}): FieldDefinition {
+    return createField("markdoc", config);
+  },
+
+  mdx(config: MdxFieldConfig = {}): FieldDefinition {
+    return createField("mdx", config);
+  },
+
+  conditional(config: ConditionalFieldConfig): FieldDefinition {
+    return createField("conditional", config);
+  },
+
+  child(config: ChildFieldConfig = {}): FieldDefinition {
+    return createField("child", config);
+  },
+
+  cloudImage(config: CloudImageFieldConfig = {}): FieldDefinition {
+    return createField("cloud-image", config);
+  },
+
+  empty(config: BaseFieldConfig = {}): FieldDefinition {
+    return createField("empty", config);
+  },
+
+  emptyContent(config: BaseFieldConfig = {}): FieldDefinition {
+    return createField("empty-content", config);
+  },
+
+  emptyDocument(config: BaseFieldConfig = {}): FieldDefinition {
+    return createField("empty-document", config);
+  },
+
+  ignored(config: BaseFieldConfig = {}): FieldDefinition {
+    return createField("ignored", config);
+  },
+};
+
+export type Fields = typeof fields;

package/src/fields/index.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Fields API barrel exports
+ *
+ * @module @writenex/astro/fields
+ */
+
+export type {
+  CollectionSchemaConfig,
+  SingletonSchemaConfig,
+} from "./collection";
+export { collection, singleton } from "./collection";
+export type { Fields } from "./fields";
+export { fields } from "./fields";
+export { resolveFieldDefinition } from "./resolve";
+export type {
+  ArrayFieldConfig,
+  BaseFieldConfig,
+  BlocksFieldConfig,
+  CheckboxFieldConfig,
+  ChildFieldConfig,
+  CloudImageFieldConfig,
+  ConditionalFieldConfig,
+  DateFieldConfig,
+  DatetimeFieldConfig,
+  FieldDefinition,
+  FieldKind,
+  FileFieldConfig,
+  ImageFieldConfig,
+  IntegerFieldConfig,
+  MarkdocFieldConfig,
+  MdxFieldConfig,
+  MultiselectFieldConfig,
+  NumberFieldConfig,
+  ObjectFieldConfig,
+  PathReferenceFieldConfig,
+  RelationshipFieldConfig,
+  SelectFieldConfig,
+  SlugFieldConfig,
+  TextFieldConfig,
+  UrlFieldConfig,
+  ValidationOptions,
+} from "./types";