nextjs-studio 1.0.5 → 1.0.7

package/dist/bin/nextjs-studio.js

@@ -6870,7 +6870,7 @@ async function loadConfigFromPath(configPath2) {
 // package.json
 var package_default = {
   name: "nextjs-studio",
-  version: "1.0.5",
+  version: "1.0.6",
   description: "A Git-based, local-first CMS for Next.js projects",
   keywords: [
     "nextjs",
@@ -6903,8 +6903,11 @@ var package_default = {
   types: "./dist/core/index.d.ts",
   bin: "dist/bin/nextjs-studio.js",
   files: [
-    "dist/bin",
-    "dist/core",
+    "dist/bin/nextjs-studio.js",
+    "dist/core/index.js",
+    "dist/core/index.d.ts",
+    "dist/core/server.js",
+    "dist/core/server.d.ts",
     "dist/*.d.ts",
     "dist/cli/ui/standalone.tar.gz",
     "README.md",

package/dist/core/index.d.ts

@@ -0,0 +1,117 @@
+import { C as ContentEntry, e as FieldDefinition, T as TextField, L as LongTextField, N as NumberField, B as BooleanField, f as DateField, I as ISODate, g as SelectField, M as MultiSelectField, U as UrlField, H as HttpUrl, E as EmailField, h as Email, i as MediaField, j as MediaPath, O as ObjectField, A as ArrayField, k as IdField, l as ID, m as SlugField, n as Slug, R as RelationField, o as FormulaField, p as StatusField, r as CreatedTimeField, s as UpdatedTimeField, t as CollectionSchema, u as BaseField } from '../query-builder-CRcrmrbR.js';
+export { a as Collection, b as CollectionConfig, c as CollectionTypeMap, v as EntryResult, w as FieldType, Q as QueryOptions, d as QueryResult, S as StudioConfig, q as queryCollection } from '../query-builder-CRcrmrbR.js';
+
+/**
+ * @context  Core layer — draft filter at src/core/draft-filter.ts
+ * @does     Provides utilities to detect and filter draft content entries
+ * @depends  src/shared/types.ts
+ * @do       Add new draft detection heuristics here
+ * @dont     Import from CLI or UI; access filesystem
+ */
+
+declare function isDraft(entry: ContentEntry): boolean;
+declare function filterDrafts(entries: ContentEntry[]): ContentEntry[];
+
+/**
+ * @context  Core layer — frontmatter binder at src/core/frontmatter-binder.ts
+ * @does     Replaces {frontmatter.X} tokens in MDX body with actual frontmatter values
+ * @depends  none
+ * @do       Add new token patterns or transformation rules here
+ * @dont     Import from CLI or UI; access filesystem
+ */
+/**
+ * Replaces `{frontmatter.X}` tokens in the body with values from the data object.
+ * Supports dot-notation for nested values (e.g. `{frontmatter.author.name}`).
+ */
+declare function bindFrontmatter(body: string, data: Record<string, unknown>): string;
+/**
+ * Extracts all frontmatter token paths from the body.
+ */
+declare function extractFrontmatterTokens(body: string): string[];
+
+/**
+ * @context  Core layer — locale parser at src/core/locale-parser.ts
+ * @does     Extracts locale codes from filenames using the convention `slug.locale.mdx`
+ * @depends  none
+ * @do       Add new locale detection strategies here
+ * @dont     Import from CLI or UI; access filesystem
+ */
+/**
+ * Parses locale from a filename.
+ * Supports `post.pt.mdx`, `post.en-US.mdx` patterns.
+ * Returns undefined for files without a locale suffix.
+ */
+declare function parseLocaleFromFilename(filename: string): string | undefined;
+/**
+ * Removes the locale suffix from a slug.
+ * Handles both pre-slugify (`.pt`) and post-slugify (`-pt`) formats,
+ * since `@sindresorhus/slugify` converts dots to dashes.
+ * `post.pt` → `post`, `post-pt` → `post`, `post` → `post`
+ */
+declare function stripLocaleFromSlug(slug: string, locale?: string): string;
+
+/**
+ * @context  Shared layer — schema inference types at src/shared/schema-types.ts
+ * @does     Provides TypeScript utility types to infer typed data shapes from CollectionSchema
+ * @depends  src/shared/fields.ts
+ * @do       Add new schema-level inference utilities here
+ * @dont     Import from CLI or UI; contain runtime logic or field definitions
+ */
+
+/** Infer the TypeScript value type for a single field definition. */
+type InferFieldValue<F extends FieldDefinition> = F extends TextField ? string : F extends LongTextField ? string : F extends NumberField ? number : F extends BooleanField ? boolean : F extends DateField ? F["includeTime"] extends true ? Date : ISODate : F extends SelectField ? F["options"][number]["value"] : F extends MultiSelectField ? Array<F["options"][number]["value"]> : F extends UrlField ? HttpUrl : F extends EmailField ? Email : F extends MediaField ? MediaPath : F extends ObjectField ? InferObjectFields<F["fields"]> : F extends ArrayField ? Array<InferObjectFields<F["itemFields"]>> : F extends IdField ? ID : F extends SlugField ? Slug : F extends RelationField ? F["multiple"] extends true ? ID[] : ID : F extends FormulaField ? F["resultType"] extends "number" ? number : F["resultType"] extends "boolean" ? boolean : string : F extends StatusField ? F["options"][number]["value"] : F extends CreatedTimeField ? Date : F extends UpdatedTimeField ? Date : never;
+/**
+ * Infer a record type from an array of field definitions.
+ * Fields marked `required: false` become optional (`T | undefined`).
+ */
+type InferObjectFields<Fields extends FieldDefinition[]> = {
+    [F in Fields[number] as F["name"]]: F extends {
+        required: false;
+    } ? InferFieldValue<F> | undefined : InferFieldValue<F>;
+};
+/**
+ * Infer the full data shape of a collection from its schema.
+ *
+ * @example
+ * ```ts
+ * const blogSchema = {
+ *   collection: "blog",
+ *   fields: [
+ *     { name: "title", type: "text", required: true },
+ *     { name: "published", type: "boolean" },
+ *   ],
+ * } satisfies CollectionSchema;
+ *
+ * type BlogData = InferSchemaData<typeof blogSchema>;
+ * // => { title: string; published: boolean }
+ * ```
+ */
+type InferSchemaData<S extends CollectionSchema> = InferObjectFields<S["fields"]>;
+
+/**
+ * @context  Shared layer — field label utilities at src/shared/field-utils.ts
+ * @does     Resolves human-readable labels for field definitions and raw key strings
+ * @depends  src/shared/fields.ts
+ * @do       Add field-related utility functions here
+ * @dont     Import from CLI or UI; contain field type definitions or schema logic
+ */
+
+/**
+ * Resolve the human-readable label for a field.
+ *
+ * When the field definition has an explicit `label`, that is returned as-is.
+ * Otherwise the `name` (camelCase / kebab-case / snake_case) is converted to Title Case:
+ *
+ * @example
+ * fieldLabel({ name: "siteName", type: "text" }) // "Site Name"
+ * fieldLabel({ name: "created_at", type: "date" }) // "Created At"
+ * fieldLabel({ name: "bio", type: "long-text", label: "About" }) // "About"
+ */
+declare function fieldLabel(field: Pick<BaseField, "name" | "label">): string;
+/**
+ * Resolve the label for a raw key string (no field definition available).
+ * Useful for dynamic keys that have no schema entry.
+ */
+declare function keyLabel(name: string): string;
+
+export { CollectionSchema, ContentEntry, FieldDefinition, type InferFieldValue, type InferSchemaData, bindFrontmatter, extractFrontmatterTokens, fieldLabel, filterDrafts, isDraft, keyLabel, parseLocaleFromFilename, stripLocaleFromSlug };

package/dist/core/server.d.ts

@@ -0,0 +1,111 @@
+import { F as FileInfo, D as DirectoryFileEntry, S as StudioConfig, C as ContentEntry, a as Collection } from '../query-builder-CRcrmrbR.js';
+export { b as CollectionConfig, c as CollectionTypeMap, Q as QueryOptions, d as QueryResult, q as queryCollection } from '../query-builder-CRcrmrbR.js';
+
+/**
+ * @context  Shared layer — FS adapter interface at src/shared/fs-adapter.interface.ts
+ * @does     Defines the IFsAdapter contract so Core can perform I/O without depending on CLI
+ * @depends  src/shared/types.ts
+ * @do       Add new I/O methods here when Core needs them; keep the interface minimal
+ * @dont     Import from CLI or UI; contain implementation logic
+ */
+
+interface IFsAdapter {
+    readFile(filePath: string): Promise<string>;
+    writeFile(filePath: string, content: string): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+    getStats(filePath: string): Promise<FileInfo>;
+    listFiles(dirPath: string, extensions?: readonly string[]): Promise<string[]>;
+    listDirectories(dirPath: string): Promise<string[]>;
+    readBuffer(filePath: string): Promise<Buffer>;
+    writeBuffer(filePath: string, data: Buffer): Promise<void>;
+    listAllFiles(dirPath: string): Promise<DirectoryFileEntry[]>;
+    join(...segments: string[]): string;
+    basename(filePath: string): string;
+    extname(filePath: string): string;
+    relative(from: string, to: string): string;
+    normalizeSlug(relativePath: string, ext: string): string;
+    readFileSync(filePath: string): string;
+    existsSync(filePath: string): boolean;
+    listFilesSync(dirPath: string, extensions?: readonly string[]): string[];
+    listDirectoriesSync(dirPath: string): string[];
+}
+
+/**
+ * @context  Core layer — filesystem adapter at src/core/fs-adapter.ts
+ * @does     Implements IFsAdapter; abstracts all file read/write/list operations behind a single interface
+ * @depends  src/shared/types.ts, src/shared/constants.ts, src/shared/fs-adapter.interface.ts
+ * @do       Add new I/O operations here; all file access must go through this adapter
+ * @dont     Import UI components, run HTTP requests, or contain business logic
+ */
+
+declare class FsAdapter implements IFsAdapter {
+    private readonly basePath;
+    constructor(basePath: string);
+    private resolve;
+    readFile(filePath: string): Promise<string>;
+    writeFile(filePath: string, content: string): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+    getStats(filePath: string): Promise<FileInfo>;
+    listFiles(dirPath: string, extensions?: readonly string[]): Promise<string[]>;
+    listDirectories(dirPath: string): Promise<string[]>;
+    readBuffer(filePath: string): Promise<Buffer>;
+    writeBuffer(filePath: string, data: Buffer): Promise<void>;
+    listAllFiles(dirPath: string): Promise<DirectoryFileEntry[]>;
+    join(...segments: string[]): string;
+    basename(filePath: string): string;
+    extname(filePath: string): string;
+    relative(from: string, to: string): string;
+    normalizeSlug(relativePath: string, ext: string): string;
+    readFileSync(filePath: string): string;
+    existsSync(filePath: string): boolean;
+    listFilesSync(dirPath: string, extensions?: readonly string[]): string[];
+    listDirectoriesSync(dirPath: string): string[];
+}
+
+/**
+ * @context  Core layer — content indexer at src/core/indexer.ts
+ * @does     Scans the contents directory, parses MDX/JSON files, and builds an in-memory index
+ * @depends  src/shared/types.ts, src/shared/constants.ts, src/shared/fs-adapter.interface.ts, src/core/parsers/, src/core/schema-inferrer.ts
+ * @do       Add new file type handling here; extend indexCollection for new collection behaviors
+ * @dont     Import from CLI or UI; instantiate FsAdapter; access the filesystem directly
+ */
+
+declare class ContentIndex {
+    private readonly entries;
+    private readonly collections;
+    private readonly fs;
+    constructor(fsAdapter: IFsAdapter);
+    build(config?: StudioConfig): Promise<void>;
+    buildSync(config?: StudioConfig): void;
+    getCollection(name: string): ContentEntry[];
+    getCollections(): Collection[];
+    clear(): void;
+    updateEntry(collectionName: string, entry: ContentEntry): void;
+    removeEntry(collectionName: string, slug: string): void;
+    private updateCollectionMeta;
+    private indexCollection;
+    private indexCollectionSync;
+    private scanDir;
+    private scanDirSync;
+    private buildMdxEntry;
+    private buildJsonEntries;
+    private readOrdering;
+    private readOrderingSync;
+    private applyOrdering;
+    private detectCollectionType;
+}
+
+/**
+ * @context  Core layer — content store at src/core/content-store.ts
+ * @does     Manages a singleton ContentIndex; exposes loadContent() and getStore() for consumers
+ * @depends  src/core/indexer.ts, src/shared/types.ts
+ * @do       Use this as the single access point for in-memory indexed content
+ * @dont     Import from CLI or UI; contain parsing or I/O logic; import fs-adapter at top level
+ */
+
+declare function loadContent(fsAdapter: IFsAdapter, config?: StudioConfig): Promise<ContentIndex>;
+declare function loadContentSync(fsAdapter: IFsAdapter, config?: StudioConfig): ContentIndex;
+
+export { Collection, ContentEntry, ContentIndex, FsAdapter, StudioConfig, loadContent, loadContentSync };

package/dist/core/server.js

@@ -0,0 +1,670 @@
+// src/core/server.ts
+import path2 from "path";
+
+// src/shared/constants.ts
+var CONTENTS_DIR = "contents";
+var SUPPORTED_EXTENSIONS = [".mdx", ".json"];
+var COLLECTION_ORDER_FILE = "collection.json";
+var IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/avif"
+];
+var VIDEO_MIME_TYPES = ["video/mp4", "video/webm", "video/ogg"];
+var AUDIO_MIME_TYPES = [
+  "audio/mpeg",
+  "audio/ogg",
+  "audio/wav",
+  "audio/webm",
+  "audio/aac",
+  "audio/flac"
+];
+var MEDIA_MIME_TYPES = [...IMAGE_MIME_TYPES, ...VIDEO_MIME_TYPES, ...AUDIO_MIME_TYPES];
+
+// src/core/fs-adapter.ts
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+var FsAdapter = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = path.resolve(basePath);
+  }
+  resolve(...segments) {
+    return path.resolve(this.basePath, ...segments);
+  }
+  async readFile(filePath) {
+    return fs.readFile(this.resolve(filePath), "utf-8");
+  }
+  async writeFile(filePath, content) {
+    const fullPath = this.resolve(filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, "utf-8");
+  }
+  async deleteFile(filePath) {
+    await fs.unlink(this.resolve(filePath));
+  }
+  async exists(filePath) {
+    try {
+      await fs.access(this.resolve(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getStats(filePath) {
+    const fullPath = this.resolve(filePath);
+    const stats = await fs.stat(fullPath);
+    return { path: filePath, size: stats.size, modifiedAt: stats.mtime };
+  }
+  async listFiles(dirPath, extensions) {
+    const fullPath = this.resolve(dirPath);
+    const filterExts = extensions ?? SUPPORTED_EXTENSIONS;
+    let entries;
+    try {
+      entries = await fs.readdir(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isFile() && filterExts.some((ext) => entry.name.endsWith(ext))).map((entry) => this.join(dirPath, entry.name));
+  }
+  async listDirectories(dirPath) {
+    const fullPath = this.resolve(dirPath);
+    let entries;
+    try {
+      entries = await fs.readdir(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => this.join(dirPath, entry.name));
+  }
+  async readBuffer(filePath) {
+    return fs.readFile(this.resolve(filePath));
+  }
+  async writeBuffer(filePath, data) {
+    const fullPath = this.resolve(filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, data);
+  }
+  async listAllFiles(dirPath) {
+    const fullPath = this.resolve(dirPath);
+    let entries;
+    try {
+      entries = await fs.readdir(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const relativePath = this.join(dirPath, entry.name);
+      const stats = await fs.stat(this.resolve(relativePath));
+      results.push({ name: entry.name, relativePath, size: stats.size, modifiedAt: stats.mtime });
+    }
+    return results;
+  }
+  join(...segments) {
+    return path.join(...segments);
+  }
+  basename(filePath) {
+    return path.basename(filePath);
+  }
+  extname(filePath) {
+    return path.extname(filePath);
+  }
+  relative(from, to) {
+    return path.relative(from, to);
+  }
+  normalizeSlug(relativePath, ext) {
+    return relativePath.replace(ext, "").split(path.sep).join("/");
+  }
+  readFileSync(filePath) {
+    return fsSync.readFileSync(this.resolve(filePath), "utf-8");
+  }
+  existsSync(filePath) {
+    return fsSync.existsSync(this.resolve(filePath));
+  }
+  listFilesSync(dirPath, extensions) {
+    const fullPath = this.resolve(dirPath);
+    const filterExts = extensions ?? SUPPORTED_EXTENSIONS;
+    let entries;
+    try {
+      entries = fsSync.readdirSync(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isFile() && filterExts.some((ext) => entry.name.endsWith(ext))).map((entry) => this.join(dirPath, entry.name));
+  }
+  listDirectoriesSync(dirPath) {
+    const fullPath = this.resolve(dirPath);
+    let entries;
+    try {
+      entries = fsSync.readdirSync(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => this.join(dirPath, entry.name));
+  }
+};
+
+// src/core/indexer.ts
+import slugify from "@sindresorhus/slugify";
+
+// src/core/parsers/parser-mdx.ts
+import matter from "gray-matter";
+
+// src/core/frontmatter-binder.ts
+var TOKEN_REGEX = /\{frontmatter\.([a-zA-Z0-9_.]+)\}/g;
+function bindFrontmatter(body, data) {
+  return body.replace(TOKEN_REGEX, (_match, path3) => {
+    const value = resolvePath(data, path3);
+    if (value === void 0 || value === null) return _match;
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  });
+}
+function resolvePath(obj, path3) {
+  const keys = path3.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+
+// src/core/parsers/parser-mdx.ts
+function normalizeDates(data) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value instanceof Date) {
+      result[key] = value.toISOString().split("T")[0];
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = normalizeDates(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseMdx(content, options) {
+  const { data: rawData, content: body } = matter(content);
+  const data = normalizeDates(rawData);
+  const trimmed = body.trim();
+  return {
+    data,
+    body: options?.bindTokens ? bindFrontmatter(trimmed, data) : trimmed
+  };
+}
+
+// src/core/parsers/parser-json.ts
+function parseJson(content) {
+  const parsed = JSON.parse(content);
+  if (Array.isArray(parsed)) {
+    return {
+      type: "json-array",
+      entries: parsed
+    };
+  }
+  if (typeof parsed === "object" && parsed !== null) {
+    return {
+      type: "json-object",
+      data: parsed
+    };
+  }
+  throw new Error("JSON content must be an array or object");
+}
+
+// src/core/schema-inferrer.ts
+var RE_ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var RE_ISO_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?$/;
+var RE_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var RE_URL = /^https?:\/\/.+/;
+var LONG_TEXT_THRESHOLD = 200;
+var RICH_TEXT_FIELD_NAMES = ["description", "descriptions", "text", "content"];
+function isISODate(value) {
+  return RE_ISO_DATE.test(value);
+}
+function isISODateTime(value) {
+  return RE_ISO_DATETIME.test(value);
+}
+function isEmail(value) {
+  return RE_EMAIL.test(value);
+}
+function isUrl(value) {
+  return RE_URL.test(value);
+}
+function inferStringField(name, strings) {
+  if (strings.every(isEmail)) return { name, type: "email" };
+  if (strings.every(isUrl)) return { name, type: "url" };
+  if (strings.every(isISODateTime)) return { name, type: "date", includeTime: true };
+  if (strings.every(isISODate)) return { name, type: "date" };
+  if (RICH_TEXT_FIELD_NAMES.includes(name.toLowerCase())) return { name, type: "long-text" };
+  const isLong = strings.some((s) => s.length > LONG_TEXT_THRESHOLD || s.includes("\n"));
+  return { name, type: isLong ? "long-text" : "text" };
+}
+function inferArrayField(name, items) {
+  if (items.length === 0) return { name, type: "array", itemFields: [] };
+  if (items.every((item) => typeof item === "string")) {
+    const unique = [...new Set(items)].slice(0, 50);
+    const options = unique.map((v) => ({ label: v, value: v }));
+    return { name, type: "multi-select", options };
+  }
+  if (items.every((item) => typeof item === "object" && item !== null && !Array.isArray(item))) {
+    return { name, type: "array", itemFields: inferFields(items) };
+  }
+  return { name, type: "array", itemFields: [] };
+}
+function inferFieldDefinition(name, values) {
+  const present = values.filter((v) => v !== null && v !== void 0);
+  if (present.length === 0) return { name, type: "text" };
+  if (present.every((v) => typeof v === "boolean")) return { name, type: "boolean" };
+  if (present.every((v) => typeof v === "number")) {
+    const format = present.every((v) => Number.isInteger(v)) ? "integer" : "decimal";
+    return { name, type: "number", format };
+  }
+  if (present.every((v) => typeof v === "string")) {
+    return inferStringField(name, present);
+  }
+  if (present.every((v) => Array.isArray(v))) {
+    return inferArrayField(name, present.flat());
+  }
+  if (present.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
+    return { name, type: "object", fields: inferFields(present) };
+  }
+  return { name, type: "text" };
+}
+function inferFields(rows) {
+  const keySet = new Set(rows.flatMap((row) => Object.keys(row)));
+  return Array.from(keySet).map((key) => inferFieldDefinition(key, rows.map((row) => row[key])));
+}
+function inferSchema(entries, collectionName) {
+  const rows = entries.map((entry) => entry.data);
+  return { collection: collectionName, fields: inferFields(rows) };
+}
+
+// src/core/locale-parser.ts
+var LOCALE_REGEX = /\.([a-z]{2}(?:-[A-Z]{2})?)\.mdx$/;
+function parseLocaleFromFilename(filename) {
+  const match = LOCALE_REGEX.exec(filename);
+  return match?.[1];
+}
+function stripLocaleFromSlug(slug, locale) {
+  if (!locale) return slug;
+  const dotSuffix = `.${locale}`;
+  if (slug.endsWith(dotSuffix)) return slug.slice(0, -dotSuffix.length);
+  const dashSuffix = `-${locale}`;
+  if (slug.endsWith(dashSuffix)) return slug.slice(0, -dashSuffix.length);
+  return slug;
+}
+
+// src/core/indexer.ts
+var ContentIndex = class {
+  entries = /* @__PURE__ */ new Map();
+  collections = /* @__PURE__ */ new Map();
+  fs;
+  constructor(fsAdapter) {
+    this.fs = fsAdapter;
+  }
+  async build(config) {
+    this.clear();
+    const dirs = await this.fs.listDirectories(".");
+    for (const dir of dirs) {
+      const dirName = this.fs.basename(dir);
+      const collectionName = slugify(dirName);
+      const collectionConfig = config?.collections?.[collectionName];
+      await this.indexCollection(dirName, collectionName, collectionConfig?.schema);
+    }
+  }
+  buildSync(config) {
+    this.clear();
+    const dirs = this.fs.listDirectoriesSync(".");
+    for (const dir of dirs) {
+      const dirName = this.fs.basename(dir);
+      const collectionName = slugify(dirName);
+      const collectionConfig = config?.collections?.[collectionName];
+      this.indexCollectionSync(dirName, collectionName, collectionConfig?.schema);
+    }
+  }
+  getCollection(name) {
+    return this.entries.get(name) ?? [];
+  }
+  getCollections() {
+    return Array.from(this.collections.values());
+  }
+  clear() {
+    this.entries.clear();
+    this.collections.clear();
+  }
+  updateEntry(collectionName, entry) {
+    const entries = this.entries.get(collectionName) ?? [];
+    const idx = entries.findIndex((e) => e.slug === entry.slug);
+    if (idx >= 0) {
+      entries[idx] = entry;
+    } else {
+      entries.push(entry);
+    }
+    this.entries.set(collectionName, entries);
+    this.updateCollectionMeta(collectionName);
+  }
+  removeEntry(collectionName, slug) {
+    const entries = this.entries.get(collectionName);
+    if (!entries) return;
+    const filtered = entries.filter((e) => e.slug !== slug);
+    this.entries.set(collectionName, filtered);
+    this.updateCollectionMeta(collectionName);
+  }
+  updateCollectionMeta(collectionName) {
+    const col = this.collections.get(collectionName);
+    const entries = this.entries.get(collectionName) ?? [];
+    if (col) {
+      this.collections.set(collectionName, {
+        ...col,
+        count: entries.length,
+        type: this.detectCollectionType(entries)
+      });
+    }
+  }
+  async indexCollection(dirName, collectionName, manualSchema) {
+    const entries = [];
+    await this.scanDir(dirName, collectionName, dirName, entries);
+    const orderPath = this.fs.join(dirName, COLLECTION_ORDER_FILE);
+    const ordering = await this.readOrdering(orderPath);
+    if (ordering) {
+      this.applyOrdering(entries, ordering);
+    }
+    const schema = manualSchema ?? inferSchema(entries, collectionName);
+    this.entries.set(collectionName, entries);
+    this.collections.set(collectionName, {
+      name: collectionName,
+      type: this.detectCollectionType(entries),
+      count: entries.length,
+      basePath: dirName,
+      schema
+    });
+  }
+  indexCollectionSync(dirName, collectionName, manualSchema) {
+    const entries = [];
+    this.scanDirSync(dirName, collectionName, dirName, entries);
+    const orderPath = this.fs.join(dirName, COLLECTION_ORDER_FILE);
+    const ordering = this.readOrderingSync(orderPath);
+    if (ordering) {
+      this.applyOrdering(entries, ordering);
+    }
+    const schema = manualSchema ?? inferSchema(entries, collectionName);
+    this.entries.set(collectionName, entries);
+    this.collections.set(collectionName, {
+      name: collectionName,
+      type: this.detectCollectionType(entries),
+      count: entries.length,
+      basePath: dirName,
+      schema
+    });
+  }
+  async scanDir(dirName, collectionName, dirPath, entries) {
+    const subDirs = await this.fs.listDirectories(dirPath);
+    for (const subDir of subDirs) {
+      await this.scanDir(dirName, collectionName, subDir, entries);
+    }
+    const files = await this.fs.listFiles(dirPath);
+    for (const filePath of files) {
+      const fileName = this.fs.basename(filePath);
+      if (fileName === COLLECTION_ORDER_FILE) continue;
+      const ext = this.fs.extname(fileName);
+      const content = await this.fs.readFile(filePath);
+      const relativePath = this.fs.relative(dirName, filePath);
+      const slug = this.fs.normalizeSlug(relativePath, ext).split("/").map((segment) => slugify(segment)).join("/");
+      if (ext === ".mdx") {
+        entries.push(this.buildMdxEntry(collectionName, slug, fileName, content));
+      } else if (ext === ".json") {
+        entries.push(...this.buildJsonEntries(collectionName, slug, content));
+      }
+    }
+  }
+  scanDirSync(dirName, collectionName, dirPath, entries) {
+    const subDirs = this.fs.listDirectoriesSync(dirPath);
+    for (const subDir of subDirs) {
+      this.scanDirSync(dirName, collectionName, subDir, entries);
+    }
+    const files = this.fs.listFilesSync(dirPath);
+    for (const filePath of files) {
+      const fileName = this.fs.basename(filePath);
+      if (fileName === COLLECTION_ORDER_FILE) continue;
+      const ext = this.fs.extname(fileName);
+      const content = this.fs.readFileSync(filePath);
+      const relativePath = this.fs.relative(dirName, filePath);
+      const slug = this.fs.normalizeSlug(relativePath, ext).split("/").map((segment) => slugify(segment)).join("/");
+      if (ext === ".mdx") {
+        entries.push(this.buildMdxEntry(collectionName, slug, fileName, content));
+      } else if (ext === ".json") {
+        entries.push(...this.buildJsonEntries(collectionName, slug, content));
+      }
+    }
+  }
+  buildMdxEntry(collectionName, slug, fileName, content) {
+    const parsed = parseMdx(content);
+    const locale = parseLocaleFromFilename(fileName);
+    const normalizedSlug = stripLocaleFromSlug(slug, locale);
+    return {
+      collection: collectionName,
+      slug: normalizedSlug,
+      path: `/${collectionName}/${normalizedSlug}`,
+      body: parsed.body,
+      data: parsed.data,
+      ...locale ? { locale } : {}
+    };
+  }
+  buildJsonEntries(collectionName, slug, content) {
+    const parsed = parseJson(content);
+    if (parsed.type === "json-array") {
+      return parsed.entries.map((data, index) => {
+        const entrySlug = typeof data["slug"] === "string" ? slugify(data["slug"]) : `${slug}/${index}`;
+        return {
+          collection: collectionName,
+          slug: entrySlug,
+          path: `/${collectionName}/${entrySlug}`,
+          data
+        };
+      });
+    }
+    return [{ collection: collectionName, slug, path: `/${collectionName}/${slug}`, data: parsed.data }];
+  }
+  async readOrdering(orderPath) {
+    if (!await this.fs.exists(orderPath)) return null;
+    try {
+      const content = await this.fs.readFile(orderPath);
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) return parsed;
+    } catch (error) {
+      console.warn(`[Nextjs Studio] Failed to parse ordering file: ${orderPath}`, error);
+    }
+    return null;
+  }
+  readOrderingSync(orderPath) {
+    if (!this.fs.existsSync(orderPath)) return null;
+    try {
+      const content = this.fs.readFileSync(orderPath);
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) return parsed;
+    } catch (error) {
+      console.warn(`[Nextjs Studio] Failed to parse ordering file: ${orderPath}`, error);
+    }
+    return null;
+  }
+  applyOrdering(entries, ordering) {
+    const orderMap = new Map(ordering.map((slug, index) => [slug, index]));
+    entries.sort((a, b) => {
+      const aIndex = orderMap.get(a.slug) ?? Infinity;
+      const bIndex = orderMap.get(b.slug) ?? Infinity;
+      return aIndex - bIndex;
+    });
+  }
+  detectCollectionType(entries) {
+    if (entries.length === 0) return "mdx";
+    const first = entries[0];
+    if (first.body !== void 0) return "mdx";
+    if (entries.length === 1 && !first.slug.includes("/")) return "json-object";
+    return "json-array";
+  }
+};
+
+// src/core/content-store.ts
+var store = null;
+function getStore() {
+  if (!store) {
+    throw new Error(
+      "Content not loaded. Auto-init requires 'nextjs-studio/server' \u2014 use loadContentSync() in a server context, or queryCollection() will auto-init when imported from 'nextjs-studio/server'."
+    );
+  }
+  return store;
+}
+function setStore(index) {
+  store = index;
+}
+function hasStore() {
+  return store !== null;
+}
+async function loadContent(fsAdapter, config) {
+  const index = new ContentIndex(fsAdapter);
+  await index.build(config);
+  store = index;
+  return index;
+}
+function loadContentSync(fsAdapter, config) {
+  const index = new ContentIndex(fsAdapter);
+  index.buildSync(config);
+  store = index;
+  return index;
+}
+
+// src/core/query-builder.ts
+import { filter, orderBy, get, slice } from "lodash-es";
+
+// src/core/draft-filter.ts
+function isDraft(entry) {
+  return entry.data.draft === true;
+}
+
+// src/core/query-builder.ts
+var QueryBuilder = class {
+  collectionName;
+  options = {};
+  _excludeDrafts = false;
+  _locale;
+  constructor(collection) {
+    this.collectionName = collection;
+  }
+  where(conditions) {
+    this.options.where = { ...this.options.where, ...conditions };
+    return this;
+  }
+  sort(field, order = "asc") {
+    this.options.sort = { field, order };
+    return this;
+  }
+  limit(count) {
+    this.options.limit = count;
+    return this;
+  }
+  offset(count) {
+    this.options.offset = count;
+    return this;
+  }
+  excludeDrafts() {
+    this._excludeDrafts = true;
+    return this;
+  }
+  locale(code) {
+    this._locale = code;
+    return this;
+  }
+  all() {
+    let entries = [...getStore().getCollection(this.collectionName)];
+    if (this._excludeDrafts) {
+      entries = entries.filter((entry) => !isDraft(entry));
+    }
+    if (this._locale) {
+      const loc = this._locale;
+      entries = entries.filter((entry) => entry.locale === loc);
+    }
+    if (this.options.where) {
+      const conditions = this.options.where;
+      entries = filter(
+        entries,
+        (entry) => Object.entries(conditions).every(([key, value]) => get(entry.data, key) === value)
+      );
+    }
+    if (this.options.sort) {
+      const { field, order } = this.options.sort;
+      entries = orderBy(entries, [(entry) => get(entry.data, field)], [order]);
+    }
+    const start = this.options.offset ?? 0;
+    const end = this.options.limit ? start + this.options.limit : void 0;
+    return slice(entries, start, end).map((e) => ({
+      collection: e.collection,
+      slug: e.slug,
+      path: e.path,
+      body: e.body,
+      locale: e.locale,
+      ...e.data
+    }));
+  }
+  first() {
+    return this.limit(1).all()[0];
+  }
+  one() {
+    const result = this.limit(1).all()[0];
+    if (result === void 0) {
+      throw new Error(`Collection "${this.collectionName}" is empty \u2014 expected exactly one entry.`);
+    }
+    return result;
+  }
+  count() {
+    return this.all().length;
+  }
+};
+var FLUENT_METHODS = /* @__PURE__ */ new Set(["where", "sort", "limit", "offset", "excludeDrafts", "locale"]);
+function wrapWithArrayProxy(builder) {
+  let cache = null;
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (FLUENT_METHODS.has(String(prop))) {
+        const method = Reflect.get(target, prop);
+        return (...args) => {
+          cache = null;
+          method.apply(target, args);
+          return receiver;
+        };
+      }
+      if (prop in target) {
+        const value2 = Reflect.get(target, prop, receiver);
+        return typeof value2 === "function" ? value2.bind(target) : value2;
+      }
+      if (!cache) cache = target.all();
+      const value = Reflect.get(cache, prop);
+      return typeof value === "function" ? value.bind(cache) : value;
+    }
+  });
+}
+function queryCollection(name) {
+  return wrapWithArrayProxy(new QueryBuilder(name));
+}
+
+// src/core/server.ts
+if (!hasStore()) {
+  const dir = path2.join(process.cwd(), CONTENTS_DIR);
+  const index = new ContentIndex(new FsAdapter(dir));
+  index.buildSync();
+  setStore(index);
+}
+export {
+  ContentIndex,
+  FsAdapter,
+  loadContent,
+  loadContentSync,
+  queryCollection
+};
+//# sourceMappingURL=server.js.map

package/dist/{query-builder-BOu-D7a1.d.ts → query-builder-CRcrmrbR.d.ts}

@@ -337,4 +337,4 @@ type QueryResult<T> = QueryBuilder<T> & T[];
 declare function queryCollection<K extends keyof CollectionTypeMap>(name: K): QueryResult<EntryResult<CollectionTypeMap[K]>>;
 declare function queryCollection(name: string): QueryResult<EntryResult>;
 
-export { type ArrayField as A, type BooleanField as B, type ContentEntry as C, type DateField as D, type EmailField as E, type FieldDefinition as F, type HttpUrl as H, type ISODate as I, type LongTextField as L, type MultiSelectField as M, type NumberField as N, type ObjectField as O, type QueryOptions as Q, type RelationField as R, type SelectField as S, type TextField as T, type UrlField as U, type Email as a, type MediaField as b, type MediaPath as c, type IdField as d, type ID as e, type SlugField as f, type Slug as g, type FormulaField as h, type StatusField as i, type CreatedTimeField as j, type UpdatedTimeField as k, type CollectionSchema as l, type BaseField as m, type Collection as n, type CollectionConfig as o, type CollectionTypeMap as p, type EntryResult as q, type FieldType as r, type QueryResult as s, type StudioConfig as t, queryCollection as u, type FileInfo as v, type DirectoryFileEntry as w };
+export { type ArrayField as A, type BooleanField as B, type ContentEntry as C, type DirectoryFileEntry as D, type EmailField as E, type FileInfo as F, type HttpUrl as H, type ISODate as I, type LongTextField as L, type MultiSelectField as M, type NumberField as N, type ObjectField as O, type QueryOptions as Q, type RelationField as R, type StudioConfig as S, type TextField as T, type UrlField as U, type Collection as a, type CollectionConfig as b, type CollectionTypeMap as c, type QueryResult as d, type FieldDefinition as e, type DateField as f, type SelectField as g, type Email as h, type MediaField as i, type MediaPath as j, type IdField as k, type ID as l, type SlugField as m, type Slug as n, type FormulaField as o, type StatusField as p, queryCollection as q, type CreatedTimeField as r, type UpdatedTimeField as s, type CollectionSchema as t, type BaseField as u, type EntryResult as v, type FieldType as w };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextjs-studio",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A Git-based, local-first CMS for Next.js projects",
   "keywords": [
     "nextjs",
@@ -33,8 +33,11 @@
   "types": "./dist/core/index.d.ts",
   "bin": "dist/bin/nextjs-studio.js",
   "files": [
-    "dist/bin",
-    "dist/core",
+    "dist/bin/nextjs-studio.js",
+    "dist/core/index.js",
+    "dist/core/index.d.ts",
+    "dist/core/server.js",
+    "dist/core/server.d.ts",
     "dist/*.d.ts",
     "dist/cli/ui/standalone.tar.gz",
     "README.md",