nextjs-studio 0.3.0 → 1.0.0

package/dist/core/index.js

@@ -5,8 +5,6 @@ import { filter, orderBy, get, slice } from "lodash-es";
 import slugify from "@sindresorhus/slugify";
 
 // src/shared/constants.ts
-var SUPPORTED_EXTENSIONS = [".mdx", ".json"];
-var COLLECTION_ORDER_FILE = "collection.json";
 var IMAGE_MIME_TYPES = [
   "image/png",
   "image/jpeg",
@@ -28,233 +26,76 @@ var MEDIA_MIME_TYPES = [...IMAGE_MIME_TYPES, ...VIDEO_MIME_TYPES, ...AUDIO_MIME_
 
 // src/core/parsers/parser-mdx.ts
 import matter from "gray-matter";
-function parseMdx(content) {
-  const { data, content: body } = matter(content);
-  return { data, body: body.trim() };
-}
 
-// 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/frontmatter-binder.ts
+var TOKEN_REGEX = /\{frontmatter\.([a-zA-Z0-9_.]+)\}/g;
+function bindFrontmatter(body, data) {
+  return body.replace(TOKEN_REGEX, (_match, path) => {
+    const value = resolvePath(data, path);
+    if (value === void 0 || value === null) return _match;
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  });
+}
+function extractFrontmatterTokens(body) {
+  const tokens = [];
+  let match;
+  const regex = new RegExp(TOKEN_REGEX.source, "g");
+  while ((match = regex.exec(body)) !== null) {
+    tokens.push(match[1]);
+  }
+  return tokens;
+}
+function resolvePath(obj, path) {
+  const keys = path.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/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;
-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" };
-  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: [] };
+// 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;
 }
-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/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);
-    }
-  }
-  getCollection(name) {
-    return this.entries.get(name) ?? [];
-  }
-  getCollections() {
-    return Array.from(this.collections.values());
-  }
-  clear() {
-    this.entries.clear();
-    this.collections.clear();
-  }
-  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
-    });
-  }
-  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, content));
-      } else if (ext === ".json") {
-        entries.push(...this.buildJsonEntries(collectionName, slug, content));
-      }
-    }
-  }
-  buildMdxEntry(collectionName, slug, content) {
-    const parsed = parseMdx(content);
-    return {
-      collection: collectionName,
-      slug,
-      path: `/${collectionName}/${slug}`,
-      body: parsed.body,
-      data: parsed.data
-    };
-  }
-  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;
-  }
-  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. Call loadContent() before querying.");
+    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;
 }
-async function loadContent(fsAdapter, config) {
-  const index = new ContentIndex(fsAdapter);
-  await index.build(config);
-  store = index;
-  return index;
+
+// src/core/draft-filter.ts
+function isDraft(entry) {
+  return entry.data.draft === true;
+}
+function filterDrafts(entries) {
+  return entries.filter((entry) => !isDraft(entry));
 }
 
 // src/core/query-builder.ts
 var QueryBuilder = class {
   collectionName;
   options = {};
+  _excludeDrafts = false;
+  _locale;
   constructor(collection) {
     this.collectionName = collection;
   }
@@ -274,8 +115,23 @@ var QueryBuilder = class {
     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(
@@ -289,132 +145,54 @@ var QueryBuilder = class {
     }
     const start = this.options.offset ?? 0;
     const end = this.options.limit ? start + this.options.limit : void 0;
-    return slice(entries, start, end);
+    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;
   }
 };
-function queryCollection(collection) {
-  return new QueryBuilder(collection);
-}
-
-// src/core/init.ts
-import path2 from "path";
-
-// src/cli/adapters/fs-adapter.ts
-import fs from "fs/promises";
-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 });
+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;
     }
-    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("/");
-  }
-};
-
-// src/core/init.ts
-async function initStudio(contentsDir, config) {
-  const dir = contentsDir ?? path2.join(process.cwd(), "contents");
-  await loadContent(new FsAdapter(dir), config);
+  });
 }
-function isStudioInitialized() {
-  try {
-    getStore();
-    return true;
-  } catch {
-    return false;
-  }
+function queryCollection(name) {
+  return wrapWithArrayProxy(new QueryBuilder(name));
 }
 
 // src/shared/field-utils.ts
@@ -426,12 +204,14 @@ function keyLabel(name) {
   return fieldLabel({ name });
 }
 export {
-  ContentIndex,
+  bindFrontmatter,
+  extractFrontmatterTokens,
   fieldLabel,
-  initStudio,
-  isStudioInitialized,
+  filterDrafts,
+  isDraft,
   keyLabel,
-  loadContent,
-  queryCollection
+  parseLocaleFromFilename,
+  queryCollection,
+  stripLocaleFromSlug
 };
 //# sourceMappingURL=index.js.map