@monkeyplus/flow 6.0.12 → 6.0.14

package/README.md

@@ -25,6 +25,11 @@ La guia detallada de authoring vive en `docs/authoring.md` e incluye:
 - como organizar templates, layouts y `*.context.ts`
 - como trabajar con `FlowIsland` y `client/islands/*`
 
+Documentacion complementaria:
+
+- `docs/modules.md`: referencia de modulos builtin
+- `docs/recipes.md`: recetas basadas en el playground actual
+
 Si vas a crear o mantener una app en Flow, ese archivo deberia ser el punto de entrada principal.
 
 ## API pública

package/modules/content/module.mjs

@@ -29,6 +29,18 @@ export default defineFlowModule({
     context.nitro.routeRules[`${options.apiBase}/**`] = {
       cors: true
     };
+    const fetchPluginPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "src/runtime/nitro-plugin.ts") : resolvePackageFile("src/runtime/nitro-plugin.ts", "src/runtime/nitro-plugin.mjs", "src/runtime/nitro-plugin.js");
+    context.nitro.plugins = context.nitro.plugins || [];
+    if (!context.nitro.plugins.includes(fetchPluginPath)) {
+      context.nitro.plugins.push(fetchPluginPath);
+    }
+    context.nitro.storage = {
+      ...context.nitro.storage || {},
+      content: {
+        driver: "fs",
+        base: contentDir
+      }
+    };
     context.nitro.runtimeConfig.flow = {
       ...typeof context.nitro.runtimeConfig.flow === "object" && context.nitro.runtimeConfig.flow ? context.nitro.runtimeConfig.flow : {},
       content: {

package/modules/content/query.d.ts

@@ -20,7 +20,7 @@ export interface ContentFileNode extends ContentEntry {
 }
 export type ContentTreeNode = ContentDirectoryNode | ContentFileNode;
 export declare function findContentEntries(entries: ContentEntry[], path?: string): ContentEntry[];
-export declare function readContentEntries(contentDir: string): ContentEntry[];
+export declare function readContentEntries(): Promise<ContentEntry[]>;
 export declare function buildContentTree(entries: ContentEntry[]): ContentTreeNode[];
 export declare function findContentTree(tree: ContentTreeNode[], path?: string): ContentTreeNode[];
 declare const _default: any;

package/modules/content/query.mjs

@@ -1,33 +1,11 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { extname, relative, resolve } from "node:path";
+import { extname } from "node:path";
 import { defineEventHandler, getQuery, getRequestURL } from "nitro/h3";
-import { useRuntimeConfig } from "nitro/runtime-config";
-function collectFiles(rootDir, currentDir = rootDir) {
-  const entries = readdirSync(currentDir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = resolve(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...collectFiles(rootDir, fullPath));
-      continue;
-    }
-    if (!entry.isFile()) {
-      continue;
-    }
-    const extension = extname(entry.name);
-    if (![".md", ".json", ".yml", ".yaml", ".txt"].includes(extension)) {
-      continue;
-    }
-    files.push(fullPath);
-  }
-  return files.sort((left, right) => left.localeCompare(right));
-}
+import { useStorage } from "nitro/storage";
 function normalizeQueryPath(path) {
-  if (!path) {
+  if (!path || path === "/") {
     return "/";
   }
-  const normalized = `/${path}`.replace(/\/+/g, "/");
-  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+  return path.startsWith("/") ? path : `/${path}`;
 }
 export function findContentEntries(entries, path) {
   const normalizedPath = normalizeQueryPath(path);
@@ -36,8 +14,8 @@ export function findContentEntries(entries, path) {
   }
   return entries.filter((entry) => entry.path === normalizedPath || entry.path.startsWith(`${normalizedPath}/`));
 }
-function normalizeContentPath(rootDir, filePath) {
-  const shortPath = relative(rootDir, filePath).replaceAll("\\", "/");
+function normalizeContentPath(keyPath) {
+  const shortPath = keyPath;
   const stem = shortPath.replace(/\.(md|json|ya?ml|txt)$/i, "");
   const segments = stem.split("/").filter(Boolean);
   return {
@@ -59,35 +37,36 @@ function parseKeyValueBlock(block) {
     return data;
   }, {});
 }
-function parseContentFile(rootDir, filePath) {
-  const raw = readFileSync(filePath, "utf8");
-  const extension = extname(filePath).toLowerCase();
-  const normalizedPath = normalizeContentPath(rootDir, filePath);
+function parseContentFile(keyPath, raw) {
+  const extension = extname(keyPath).toLowerCase();
+  const normalizedPath = normalizeContentPath(keyPath);
   if (extension === ".json") {
-    const parsed = JSON.parse(raw);
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const body = typeof raw === "string" ? raw : JSON.stringify(raw);
     return {
       ...normalizedPath,
       extension,
       title: typeof parsed.title === "string" ? parsed.title : void 0,
-      body: raw,
+      body,
       data: parsed
     };
   }
-  if ((extension === ".yml" || extension === ".yaml") && raw.trim()) {
-    const data = parseKeyValueBlock(raw);
+  const rawString = String(raw);
+  if ((extension === ".yml" || extension === ".yaml") && rawString.trim()) {
+    const data = parseKeyValueBlock(rawString);
     return {
       ...normalizedPath,
       extension,
       title: data.title,
-      body: raw,
+      body: rawString,
       data
     };
   }
-  if (raw.startsWith("---\n")) {
-    const end = raw.indexOf("\n---\n", 4);
+  if (rawString.startsWith("---\n")) {
+    const end = rawString.indexOf("\n---\n", 4);
     if (end >= 0) {
-      const frontmatter = raw.slice(4, end);
-      const body = raw.slice(end + 5).trim();
+      const frontmatter = rawString.slice(4, end);
+      const body = rawString.slice(end + 5).trim();
       const data = parseKeyValueBlock(frontmatter);
       return {
         ...normalizedPath,
@@ -101,15 +80,60 @@ function parseContentFile(rootDir, filePath) {
   return {
     ...normalizedPath,
     extension,
-    body: raw,
+    body: rawString,
     data: {}
   };
 }
-export function readContentEntries(contentDir) {
-  if (!contentDir || !existsSync(contentDir)) {
-    return [];
+export async function readContentEntries() {
+  const storage = useStorage("content");
+  const keys = await storage.getKeys();
+  const entries = [];
+  if (keys.length === 0) {
+    try {
+      const fs = await import("node:fs/promises");
+      const path = await import("node:path");
+      const contentDir = path.resolve(process.cwd(), "content");
+      async function walkDir(dir, baseDir) {
+        const files = await fs.readdir(dir, { withFileTypes: true });
+        for (const file of files) {
+          const res = path.resolve(dir, file.name);
+          if (file.isDirectory()) {
+            await walkDir(res, baseDir);
+          } else {
+            const extension = path.extname(res).toLowerCase();
+            if ([".md", ".json", ".yml", ".yaml", ".txt"].includes(extension)) {
+              const relativePath = path.relative(baseDir, res);
+              const normalizedKey = relativePath.replace(/\\/g, "/");
+              const raw = await fs.readFile(res, "utf-8");
+              const entry = parseContentFile(normalizedKey, raw);
+              entries.push(entry);
+            }
+          }
+        }
+      }
+      try {
+        await fs.access(contentDir);
+        await walkDir(contentDir, contentDir);
+      } catch (e) {
+      }
+      return entries.sort((left, right) => left.path.localeCompare(right.path));
+    } catch (e) {
+      console.error("[Flow Content] fs fallback failed:", e);
+    }
+  }
+  for (const key of keys) {
+    const normalizedKey = key.replace(/:/g, "/");
+    const extension = extname(normalizedKey).toLowerCase();
+    if (![".md", ".json", ".yml", ".yaml", ".txt"].includes(extension)) {
+      continue;
+    }
+    const raw = await storage.getItem(key);
+    if (raw !== null && raw !== void 0) {
+      const entry = parseContentFile(normalizedKey, raw);
+      entries.push(entry);
+    }
   }
-  return collectFiles(contentDir).map((filePath) => parseContentFile(contentDir, filePath));
+  return entries.sort((left, right) => left.path.localeCompare(right.path));
 }
 function sortTree(nodes) {
   nodes.sort((left, right) => {
@@ -129,17 +153,19 @@ export function buildContentTree(entries) {
   const roots = [];
   const directories = /* @__PURE__ */ new Map();
   for (const entry of entries) {
-    const segments = entry.stem.split("/").filter(Boolean);
-    const dirSegments = segments.slice(0, -1);
+    const parts = entry.path.split("/").filter(Boolean);
+    let currentPath = "";
     let siblings = roots;
-    for (let index = 0; index < dirSegments.length; index += 1) {
-      const stem = dirSegments.slice(0, index + 1).join("/");
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      currentPath += `/${part}`;
+      const stem = currentPath.slice(1);
       let directory = directories.get(stem);
       if (!directory) {
         directory = {
           kind: "directory",
-          name: dirSegments[index],
-          path: `/${stem}`,
+          name: part,
+          path: currentPath,
           stem,
           children: []
         };
@@ -172,19 +198,93 @@ export function findContentTree(tree, path) {
   }
   return [];
 }
-export default defineEventHandler((event) => {
-  const runtimeConfig = useRuntimeConfig();
+function getField(obj, path) {
+  return path.split(".").reduce((acc, part) => acc && acc[part], obj);
+}
+function setField(obj, path, value) {
+  const parts = path.split(".");
+  const last = parts.pop();
+  const target = parts.reduce((acc, part) => {
+    if (!acc[part])
+      acc[part] = {};
+    return acc[part];
+  }, obj);
+  target[last] = value;
+}
+export default defineEventHandler(async (event) => {
   const query = getQuery(event);
-  const contentDir = runtimeConfig.flow?.content?.dir;
   const requestUrl = getRequestURL(event);
   const isTreeRequest = requestUrl.pathname.endsWith("/tree") || query.tree === true || query.tree === "true" || query.tree === "1";
-  const entries = readContentEntries(contentDir || "");
+  let entries = await readContentEntries();
   if (isTreeRequest) {
     const tree = buildContentTree(entries);
     return findContentTree(tree, query.path);
   }
   if (query.path) {
-    return findContentEntries(entries, query.path);
+    entries = findContentEntries(entries, query.path);
+  }
+  if (query.where) {
+    try {
+      const whereConditions = JSON.parse(query.where);
+      entries = entries.filter((entry) => {
+        return whereConditions.every((cond) => {
+          const val = getField(entry, cond.field);
+          switch (cond.operator.toUpperCase()) {
+            case "=":
+              return val === cond.value;
+            case "!=":
+              return val !== cond.value;
+            case ">":
+              return val > cond.value;
+            case ">=":
+              return val >= cond.value;
+            case "<":
+              return val < cond.value;
+            case "<=":
+              return val <= cond.value;
+            case "IN":
+              return Array.isArray(cond.value) && cond.value.includes(val);
+            case "LIKE":
+              return typeof val === "string" && val.includes(cond.value);
+            default:
+              return false;
+          }
+        });
+      });
+    } catch {
+    }
+  }
+  if (query.order) {
+    try {
+      const orderConditions = JSON.parse(query.order);
+      entries = entries.sort((a, b) => {
+        for (const cond of orderConditions) {
+          const valA = getField(a, cond.field);
+          const valB = getField(b, cond.field);
+          if (valA === valB)
+            continue;
+          const dir = cond.direction.toUpperCase() === "DESC" ? -1 : 1;
+          return valA > valB ? dir : -dir;
+        }
+        return 0;
+      });
+    } catch {
+    }
+  }
+  const skip = query.skip ? Number.parseInt(query.skip, 10) : 0;
+  const limit = query.limit ? Number.parseInt(query.limit, 10) : 0;
+  if (skip > 0 || limit > 0) {
+    entries = entries.slice(skip, limit > 0 ? skip + limit : void 0);
+  }
+  if (query.select) {
+    const fields = query.select.split(",");
+    entries = entries.map((entry) => {
+      const result = {};
+      for (const field of fields) {
+        setField(result, field, getField(entry, field));
+      }
+      return result;
+    });
   }
   return entries;
 });

package/modules/netlify-cms/handler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/modules/netlify-cms/handler.mjs

@@ -0,0 +1,5 @@
+import { defineEventHandler } from "nitro/h3";
+console.log("Loading handler.ts");
+export default defineEventHandler(async (event) => {
+  return "hola";
+});

package/modules/netlify-cms/module.d.ts

@@ -0,0 +1,6 @@
+export interface NetlifyCmsModuleOptions {
+    base?: string;
+    dir?: string;
+}
+declare const _default: import("../../src/runtime/config.ts").FlowModuleDefinition<NetlifyCmsModuleOptions>;
+export default _default;

package/modules/netlify-cms/module.mjs

@@ -0,0 +1,66 @@
+import { resolve } from "node:path";
+import process from "node:process";
+import { resolvePackageFile, resolvePackagePath } from "../../src/public/shared.mjs";
+import { defineFlowModule } from "../../src/runtime/config.mjs";
+export default defineFlowModule({
+  meta: {
+    name: "netlify-cms",
+    configKey: "netlifyCms"
+  },
+  defaults: {
+    base: "/cms",
+    dir: "content"
+  },
+  setup(options, context) {
+    const isDev = process.env.NODE_ENV !== "production";
+    const handlerPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/netlify-cms/server/api/local-fs.ts") : resolvePackageFile("modules/netlify-cms/server/api/local-fs.ts", "modules/netlify-cms/server/api/local-fs.mjs", "modules/netlify-cms/server/api/local-fs.js");
+    const configHandlerPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/netlify-cms/server/api/config.ts") : resolvePackageFile("modules/netlify-cms/server/api/config.ts", "modules/netlify-cms/server/api/config.mjs", "modules/netlify-cms/server/api/config.js");
+    const adminHandlerPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/netlify-cms/server/api/admin.ts") : resolvePackageFile("modules/netlify-cms/server/api/admin.ts", "modules/netlify-cms/server/api/admin.mjs", "modules/netlify-cms/server/api/admin.js");
+    const metaHandlerPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/netlify-cms/server/api/meta.ts") : resolvePackageFile("modules/netlify-cms/server/api/meta.ts", "modules/netlify-cms/server/api/meta.mjs", "modules/netlify-cms/server/api/meta.js");
+    const locales = context.flowConfig.locale?.locales || ["es"];
+    context.nitro.virtual = context.nitro.virtual || {};
+    context.nitro.virtual["#cms-meta"] = `export const localeConfig = ${JSON.stringify(context.flowConfig.locale || {})};`;
+    context.nitro.handlers.push({
+      method: "get",
+      route: "/cms/v2/app/**",
+      handler: adminHandlerPath
+    });
+    context.nitro.handlers.push({
+      method: "get",
+      route: "/cms/v2/app.html",
+      handler: adminHandlerPath
+    });
+    context.nitro.handlers.push({
+      method: "get",
+      route: "/_flow/cms-meta.json",
+      handler: metaHandlerPath
+    });
+    context.prerenderRoutes?.add("/_flow/cms-meta.json");
+    context.prerenderRoutes?.add("/cms/v2/app.html");
+    for (const locale of locales) {
+      const configRoute = `/cms/${locale}/config.yml`;
+      context.nitro.handlers.push({
+        method: "get",
+        route: configRoute,
+        handler: configHandlerPath
+      });
+      context.prerenderRoutes?.add(configRoute);
+    }
+    if (isDev) {
+      context.nitro.handlers.push({
+        method: "post",
+        route: "/api/v1",
+        handler: handlerPath
+      });
+      context.nitro.routeRules = context.nitro.routeRules || {};
+      context.nitro.routeRules["/api/v1"] = {
+        cors: true
+      };
+      context.nitro.imports = context.nitro.imports || { imports: [] };
+      (context.nitro.imports.imports = context.nitro.imports.imports || []).push({
+        name: "defineCmsCollection",
+        from: resolvePackageFile("modules/netlify-cms/server/lib/composables.ts", "modules/netlify-cms/server/lib/composables.mjs", "modules/netlify-cms/server/lib/composables.js")
+      });
+    }
+  }
+});

package/modules/netlify-cms/resources/admin.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Content Manager</title>
+    <link href="configV1.yml" type="text/yaml" rel="cms-config-url">
+
+    <!-- Include the script that enables Netlify Identity on this page. -->
+    <script src="https://identity.netlify.com/v1/netlify-identity-widget.js"></script>
+  </head>
+  <body>
+    <!-- Include the script that builds the page and powers Netlify CMS -->
+    <script src="https://unpkg.com/netlify-cms@^2.0.0/dist/netlify-cms.js"></script>
+  </body>
+</html>

package/modules/netlify-cms/resources/adminV2.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cms</title>
+    <link rel="stylesheet" href="https://cms2-demo.netlify.app/assets/windi.css">
+    <link rel="stylesheet" href="https://cms2-demo.netlify.app/assets/cms.css">
+    <script  type="module" crossorigin src="https://cms2-demo.netlify.app/assets/cms.js"></script>
+</head>
+<body>
+    <div id="app"></div>
+</body>
+</html>

package/modules/netlify-cms/runtime/cms.d.ts

@@ -0,0 +1,3 @@
+export { defineCmsCollection } from '../server/lib/composables';
+export { widgets } from '../server/lib/cms/widgets';
+export { collections } from '../server/lib/cms/helpers';

package/modules/netlify-cms/runtime/cms.mjs

@@ -0,0 +1,3 @@
+export { defineCmsCollection } from "../server/lib/composables.mjs";
+export { widgets } from "../server/lib/cms/widgets.mjs";
+export { collections } from "../server/lib/cms/helpers.mjs";

package/modules/netlify-cms/server/api/admin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/modules/netlify-cms/server/api/admin.mjs

@@ -0,0 +1,20 @@
+import { defineEventHandler, setResponseHeader } from "nitro/h3";
+const adminHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cms</title>
+    <link rel="stylesheet" href="https://cms2-demo.netlify.app/assets/windi.css">
+    <link rel="stylesheet" href="https://cms2-demo.netlify.app/assets/cms.css">
+    <script  type="module" crossorigin src="https://cms2-demo.netlify.app/assets/cms.js"><\/script>
+</head>
+<body>
+    <div id="app"></div>
+</body>
+</html>`;
+export default defineEventHandler(async (event) => {
+  setResponseHeader(event, "Content-Type", "text/html;charset=utf-8");
+  return adminHtml;
+});

package/modules/netlify-cms/server/api/config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/modules/netlify-cms/server/api/config.mjs

@@ -0,0 +1,72 @@
+import defu from "defu";
+import yml from "js-yaml";
+import { defineEventHandler, setResponseHeader } from "nitro/h3";
+import { collections, defineCms } from "../lib/cms/helpers.mjs";
+import { widgets } from "../lib/cms/widgets.mjs";
+import fs from "node:fs";
+import { resolve } from "node:path";
+import { createJiti } from "jiti";
+import process from "node:process";
+import { defineCmsCollection } from "../lib/composables.mjs";
+export default defineEventHandler(async (event) => {
+  if (!globalThis.defineCmsCollection) {
+    globalThis.defineCmsCollection = defineCmsCollection;
+  }
+  const urlParts = event.path?.split("?")[0].split("/") || [];
+  urlParts.pop();
+  const locale = urlParts.pop() || "es";
+  const options = {};
+  const defaultOptions = {
+    config: {
+      backend: {
+        name: "git-gateway",
+        branch: "master"
+      },
+      media_folder: "public/media",
+      public_folder: "/media",
+      locale,
+      local_backend: {
+        url: "/api/v1"
+      }
+    },
+    base: "/"
+  };
+  const { config, base } = defu(options, defaultOptions);
+  config.media_folder = base + config.media_folder;
+  const projectRoot = process.cwd();
+  const cmsDir = resolve(projectRoot, "cms");
+  let loadedCollections = [];
+  try {
+    if (fs.existsSync(cmsDir)) {
+      const jiti = createJiti(resolve(projectRoot, "cms", "dummy.ts"), { interopDefault: true, fsCache: false, requireCache: false });
+      const walkSync = (dir, filelist = []) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+          const filepath = resolve(dir, file);
+          const stat = fs.statSync(filepath);
+          if (stat.isDirectory()) {
+            filelist = walkSync(filepath, filelist);
+          } else if (file.endsWith(".ts")) {
+            filelist.push(filepath);
+          }
+        }
+        return filelist;
+      };
+      const cmsFiles = walkSync(cmsDir);
+      for (const filePath of cmsFiles) {
+        const mod = jiti(filePath);
+        const colFn = mod.default || mod;
+        if (typeof colFn === "function") {
+          loadedCollections.push(colFn);
+        }
+      }
+    }
+  } catch (e) {
+    console.error("[CMS CONFIG] Error loading collections dynamically:", e);
+  }
+  const resolvedCollections = loadedCollections.map((c) => c({ widgets, collections }));
+  const manifest = defineCms(config, resolvedCollections)(`${base}content/${locale}/`, { rootDir: base });
+  const ymlConfig = yml.dump(manifest, { skipInvalid: true });
+  setResponseHeader(event, "Content-Type", "text/yml;charset=utf-8");
+  return ymlConfig;
+});

package/modules/netlify-cms/server/api/local-fs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;