@monkeyplus/flow 6.0.13 → 6.0.14

package/modules/netlify-cms/server/api/local-fs.mjs

@@ -0,0 +1,189 @@
+import { Buffer } from "node:buffer";
+import { basename, join, resolve } from "node:path";
+import process from "node:process";
+import { defineEventHandler, readBody, setResponseStatus } from "nitro/h3";
+import * as v from "valibot";
+import { entriesFromFiles, readMediaFile } from "../lib/entries.mjs";
+import { deleteFile, listRepoFiles, move, writeFile } from "../lib/fs.mjs";
+const repoPath = resolve(process.cwd());
+const paramsSchema = v.variant("action", [
+  v.object({ action: v.literal("info") }),
+  v.object({
+    action: v.literal("entriesByFolder"),
+    params: v.object({
+      folder: v.string(),
+      extension: v.string(),
+      depth: v.number()
+    })
+  }),
+  v.object({
+    action: v.literal("entriesByFiles"),
+    params: v.object({
+      files: v.array(v.object({
+        path: v.string(),
+        label: v.optional(v.string())
+      }))
+    })
+  }),
+  v.object({
+    action: v.literal("getEntry"),
+    params: v.object({
+      path: v.string()
+    })
+  }),
+  v.object({
+    action: v.literal("persistEntry"),
+    params: v.object({
+      entry: v.optional(v.object({
+        slug: v.string(),
+        path: v.string(),
+        raw: v.string(),
+        newPath: v.optional(v.string())
+      })),
+      dataFiles: v.optional(v.array(v.object({
+        slug: v.string(),
+        path: v.string(),
+        raw: v.string(),
+        newPath: v.optional(v.string())
+      }))),
+      assets: v.array(v.object({
+        path: v.string(),
+        content: v.string(),
+        encoding: v.union([v.literal("base64"), v.string()])
+      }))
+    })
+  }),
+  v.object({
+    action: v.literal("getMedia"),
+    params: v.object({
+      mediaFolder: v.string()
+    })
+  }),
+  v.object({
+    action: v.literal("getMediaFile"),
+    params: v.object({
+      path: v.string()
+    })
+  }),
+  v.object({
+    action: v.literal("persistMedia"),
+    params: v.object({
+      asset: v.object({
+        path: v.string(),
+        content: v.string(),
+        encoding: v.union([v.literal("base64"), v.string()])
+      })
+    })
+  }),
+  v.object({
+    action: v.literal("deleteFile"),
+    params: v.object({
+      path: v.string()
+    })
+  }),
+  v.object({
+    action: v.literal("deleteFiles"),
+    params: v.object({
+      paths: v.array(v.string())
+    })
+  }),
+  v.object({
+    action: v.literal("getDeployPreview"),
+    params: v.any()
+  })
+]);
+export default defineEventHandler(async (event) => {
+  const rawBody = await readBody(event);
+  if (!rawBody || !rawBody.action) {
+    setResponseStatus(event, 422);
+    return { error: "Unknown action" };
+  }
+  const result = v.safeParse(paramsSchema, rawBody);
+  if (!result.success) {
+    setResponseStatus(event, 422);
+    return { error: "Validation failed", details: result.issues };
+  }
+  const body = result.output;
+  try {
+    switch (body.action) {
+      case "info":
+        return {
+          repo: basename(repoPath),
+          publish_modes: ["simple"],
+          type: "local_fs"
+        };
+      case "entriesByFolder": {
+        const { folder, extension, depth } = body.params;
+        const files = await listRepoFiles(repoPath, folder, extension, depth);
+        const entries = await entriesFromFiles(
+          repoPath,
+          files.reverse().map((file) => ({ path: file }))
+        );
+        return entries;
+      }
+      case "entriesByFiles": {
+        const entries = await entriesFromFiles(repoPath, body.params.files);
+        return entries;
+      }
+      case "getEntry": {
+        const [entry] = await entriesFromFiles(repoPath, [{ path: body.params.path }]);
+        return entry;
+      }
+      case "persistEntry": {
+        const dataFiles = body.params.dataFiles || (body.params.entry ? [body.params.entry] : []);
+        await Promise.all(
+          dataFiles.map((dataFile) => writeFile(join(repoPath, dataFile.path), dataFile.raw))
+        );
+        await Promise.all(
+          body.params.assets.map((a) => writeFile(
+            join(repoPath, a.path),
+            Buffer.from(a.content, a.encoding)
+          ))
+        );
+        if (dataFiles.every((dataFile) => dataFile.newPath)) {
+          await Promise.all(dataFiles.map(
+            (dataFile) => move(join(repoPath, dataFile.path), join(repoPath, dataFile.newPath))
+          ));
+        }
+        return { message: "entry persisted" };
+      }
+      case "getMedia": {
+        const files = await listRepoFiles(repoPath, body.params.mediaFolder, "", 1);
+        const mediaFiles = await Promise.all(
+          files.map((file) => readMediaFile(repoPath, file))
+        );
+        return mediaFiles;
+      }
+      case "getMediaFile": {
+        const mediaFile = await readMediaFile(repoPath, body.params.path);
+        return mediaFile;
+      }
+      case "persistMedia": {
+        const asset = body.params.asset;
+        await writeFile(
+          join(repoPath, asset.path),
+          Buffer.from(asset.content, asset.encoding)
+        );
+        const file = await readMediaFile(repoPath, asset.path);
+        return file;
+      }
+      case "deleteFile": {
+        await deleteFile(repoPath, body.params.path);
+        return { message: `deleted file ${body.params.path}` };
+      }
+      case "deleteFiles": {
+        await Promise.all(
+          body.params.paths.map((filePath) => deleteFile(repoPath, filePath))
+        );
+        return { message: `deleted files ${body.params.paths.join(", ")}` };
+      }
+      case "getDeployPreview": {
+        return null;
+      }
+    }
+  } catch (e) {
+    console.error(`Error handling ${JSON.stringify(rawBody)}: ${e.message}`);
+    setResponseStatus(event, 500);
+    return { error: "Unknown error" };
+  }
+});

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

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

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

@@ -0,0 +1,8 @@
+import { defineEventHandler, setResponseHeader } from "nitro/h3";
+import { localeConfig } from "#cms-meta";
+export default defineEventHandler(async (event) => {
+  setResponseHeader(event, "Content-Type", "application/json;charset=utf-8");
+  return {
+    locale: localeConfig
+  };
+});

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

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

package/modules/netlify-cms/server/lib/cms/handler.mjs

@@ -0,0 +1,37 @@
+import defu from "defu";
+import { eventHandler } from "h3";
+import yml from "js-yaml";
+import { collections, defineCms } from "./helpers.mjs";
+import { widgets } from "./widgets.mjs";
+export default eventHandler(async (event) => {
+  const parts = event.req.url.split("/");
+  const { utils } = event.context.flow.app;
+  parts.pop();
+  const locale = parts.pop();
+  const options = event.context.flow.$config.netlifyCms || {};
+  const defaultOptions = {
+    config: {
+      backend: {
+        name: "git-gateway",
+        branch: "master"
+      },
+      media_folder: "public/media",
+      public_folder: "/media",
+      locale: "es",
+      local_backend: {
+        url: "/cms-api/api/v1"
+      }
+    },
+    base: "/"
+  };
+  const { config, base } = defu(options || {}, defaultOptions);
+  config.media_folder = base + config.media_folder;
+  const _collections = await utils.getCmsCollections(locale, {
+    widgets,
+    collections
+  });
+  const manifest = defineCms(config, [..._collections])(`${base}content/${locale}/`, { rootDir: base });
+  const ymlConfig = yml.dump(manifest, { skipInvalid: true });
+  event.res.setHeader("Content-Type", "text/yml;charset=utf-8");
+  return ymlConfig;
+});

package/modules/netlify-cms/server/lib/cms/handlerV1.d.ts

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

package/modules/netlify-cms/server/lib/cms/handlerV1.mjs

@@ -0,0 +1,40 @@
+import defu from "defu";
+import { eventHandler } from "h3";
+import yml from "js-yaml";
+import { collections, defineCms } from "./helpers.mjs";
+import { widgets } from "./widgets.mjs";
+export default eventHandler(async (event) => {
+  const parts = event.req.url.split("/");
+  const { utils } = event.context.flow.app;
+  parts.pop();
+  const locale = parts.pop();
+  const options = event.context.flow.$config.netlifyCms || {};
+  const defaultOptions = {
+    config: {
+      backend: {
+        name: "git-gateway",
+        branch: "master"
+      },
+      media_folder: "public/media",
+      public_folder: "/media",
+      locale: "es",
+      local_backend: {
+        url: "/cms-api/api/v1"
+      }
+    },
+    base: "/"
+  };
+  const { config, base } = defu(options || {}, defaultOptions);
+  config.media_folder = base + config.media_folder;
+  const _collections = await utils.getCmsCollections(locale, {
+    widgets: {
+      ...widgets,
+      image: widgets.imageV1
+    },
+    collections
+  });
+  const manifest = defineCms(config, [..._collections])(`${base}content/${locale}/`, { rootDir: base });
+  const ymlConfig = yml.dump(manifest, { skipInvalid: true });
+  event.res.setHeader("Content-Type", "text/yml;charset=utf-8");
+  return ymlConfig;
+});

package/modules/netlify-cms/server/lib/cms/helpers.d.ts

@@ -0,0 +1,14 @@
+import type { CollectionFolderId, Collections, DefineCms, DefineMethod, DefineMethodExtend, Helpers, Model } from '../types';
+export declare function mapObjIndexed<T, TResult, TKey extends string>(fn: (value: T, key: TKey, obj?: Record<TKey, T>) => TResult, obj: Record<TKey, T>): Record<TKey, TResult>;
+export declare function collectionFile(base: Omit<Collections._Base, 'name'> & {
+    fields: Model.Fields;
+}): DefineMethodExtend<Collections.File>;
+declare function collectionFolder(base: CollectionFolderId): (dir: string) => DefineMethod<Collections.Folder>;
+export declare const collections: {
+    folder: typeof collectionFolder;
+    files: Helpers.CollectionFiles;
+    file: typeof collectionFile;
+};
+export type AllCollections = typeof collections;
+export declare const defineCms: DefineCms;
+export {};

package/modules/netlify-cms/server/lib/cms/helpers.mjs

@@ -0,0 +1,76 @@
+import path from "node:path";
+export function mapObjIndexed(fun, object) {
+  return Object.entries(object).reduce((acc, [key, any]) => {
+    return {
+      ...acc,
+      [key]: fun(any, key)
+    };
+  }, {});
+}
+const collectionFiles = (base) => {
+  return (dir) => (baseDir, ctx) => {
+    const _list = mapObjIndexed((fileBase, name) => {
+      return fileBase(name);
+    }, base.files);
+    const parentDir = path.join(baseDir, dir);
+    const files = Object.values(_list).map(
+      (file) => file(parentDir, ctx)
+    );
+    const obj = {
+      name: parseName(path.join(dir)),
+      ...base,
+      // description: `${localeDir.toUpperCase()}, `,
+      files
+    };
+    delete obj.id;
+    return obj;
+  };
+};
+function parseName(name) {
+  const preName = name.replace(/\//g, "_");
+  return preName.charAt(0) === "_" ? preName.replace("_", "") : preName;
+}
+export function collectionFile(base) {
+  return (id) => (dirParent, ctx) => {
+    const file = path.join(dirParent, id);
+    const _fields = mapObjIndexed((buildField, id2) => {
+      return buildField(id2, ctx);
+    }, base.fields);
+    return {
+      name: parseName(path.join(path.basename(dirParent), id)),
+      ...base,
+      file: `${file}.${base.extension ? base.extension : "json"}`,
+      fields: Object.values(_fields)
+    };
+  };
+}
+function collectionFolder(base) {
+  return (dir) => (baseDir, ctx) => {
+    const _fields = mapObjIndexed((buildField, id) => {
+      return buildField(id, ctx);
+    }, base.fields);
+    const folder = path.join(baseDir, dir);
+    const obj = {
+      name: parseName(path.join(dir)),
+      ...base,
+      extension: base.extension || "json",
+      folder,
+      fields: Object.values(_fields)
+      // identifier_field: '',
+    };
+    delete obj.id;
+    return obj;
+  };
+}
+export const collections = {
+  folder: collectionFolder,
+  files: collectionFiles,
+  file: collectionFile
+};
+export const defineCms = (options, _collections) => (dir, ctx) => {
+  const collections2 = _collections.map((c) => c(dir, ctx));
+  return {
+    ...options,
+    collections: collections2
+  };
+};

package/modules/netlify-cms/server/lib/cms/widgets.d.ts

@@ -0,0 +1,113 @@
+import type { ContextWidget, Model, Widgets } from '../types';
+export type BuildWidget<R> = (id: string, ctx: ContextWidget) => R;
+export type WidgetInput<T> = Omit<T, 'widget' | 'name' | 'label'> & {
+    label?: string;
+};
+/**
+ * Boolean
+ */
+export declare function boolean(options?: Omit<Widgets.Boolean, 'widget' | 'name'>): BuildWidget<Widgets.Boolean>;
+/**
+ * Markdown
+ */
+export declare function markdown(options?: Omit<Widgets.Markdown, 'widget' | 'name'>): BuildWidget<Widgets.Markdown>;
+/**
+ * Code
+ */
+export declare function code(options?: Omit<Widgets.Code, 'widget' | 'name'>): BuildWidget<Widgets.Code>;
+/**
+ * Color
+ */
+export declare function color(options?: WidgetInput<Widgets.Color>): BuildWidget<Widgets.Color>;
+/**
+ * DateTime
+ */
+export declare function dateTime(options?: Omit<Widgets.DateTime, 'widget' | 'name'>): BuildWidget<Widgets.DateTime>;
+/**
+ * Hidden
+ */
+export declare function hidden(options?: Omit<Widgets.Hidden, 'widget' | 'name'>): BuildWidget<Widgets.Hidden>;
+/**
+ * List
+ */
+export declare function list(options: Omit<Widgets.List, 'widget' | 'name' | 'fields'> & {
+    fields: Model.Fields;
+}): BuildWidget<Widgets.List>;
+/**
+ * Map
+ */
+export declare function map(options: Omit<Widgets.Map, 'widget' | 'name'>): BuildWidget<Widgets.Map>;
+/**
+ * Number
+ */
+export declare function number(options: Omit<Widgets.Number, 'widget' | 'name'>): BuildWidget<Widgets.Number>;
+/**
+ * Object
+ */
+export declare function object(options: Omit<Widgets.Object, 'widget' | 'name' | 'fields'> & {
+    fields: Model.Fields;
+}): BuildWidget<Widgets.Object>;
+/**
+ * Select
+ */
+export declare function select(options: Omit<Widgets.Select, 'widget' | 'name'>): BuildWidget<Widgets.Select>;
+/**
+ * Text
+ */
+export declare function text(options: Omit<Widgets.Text, 'widget' | 'name'>): BuildWidget<Widgets.Text>;
+/**
+ * String
+ */
+export declare function string(options?: WidgetInput<Widgets.String>): BuildWidget<Widgets.String>;
+/**
+ * Relation
+ */
+export declare function relation(options: Omit<Widgets.Relation, 'widget' | 'name'>): BuildWidget<Widgets.Relation>;
+/**
+ * File
+ */
+export declare function file(options?: WidgetInput<Widgets.File>): BuildWidget<Widgets.File>;
+/**
+ * Image
+ */
+export declare function image(options?: WidgetInput<Widgets.Image>): BuildWidget<Widgets.Image>;
+/**
+ * Image
+ */
+export declare function imageV1(options?: WidgetInput<Widgets.Image>): BuildWidget<Widgets.Object>;
+/**
+ * Date
+ */
+export declare function date(options?: Omit<Widgets.Date, 'label' | 'name'>): BuildWidget<Widgets.Date>;
+/**
+ * Custom
+ */
+export declare function custom(options?: Omit<Widgets.Meta, 'label' | 'name'>): BuildWidget<Widgets.Meta>;
+/**
+ ******************** Owner widgets ****************************
+ */
+/**
+ *****************************************
+ */
+export declare const widgets: {
+    string: typeof string;
+    color: typeof color;
+    number: typeof number;
+    custom: typeof custom;
+    hidden: typeof hidden;
+    file: typeof file;
+    date: typeof date;
+    dateTime: typeof dateTime;
+    code: typeof code;
+    image: typeof image;
+    markdown: typeof markdown;
+    object: typeof object;
+    boolean: typeof boolean;
+    imageV1: typeof imageV1;
+    list: typeof list;
+    text: typeof text;
+    map: typeof map;
+    select: typeof select;
+    relation: typeof relation;
+};
+export type AllWidgets = typeof widgets;

package/modules/netlify-cms/server/lib/cms/widgets.mjs

@@ -0,0 +1,168 @@
+import { join } from "node:path";
+import { mapObjIndexed } from "./helpers.mjs";
+function returnWidget(widget, options = {}) {
+  return (name, ctx) => ({
+    name,
+    ...widget,
+    label: name,
+    ...options
+  });
+}
+export function boolean(options) {
+  return returnWidget(
+    { widget: "boolean" },
+    options
+  );
+}
+export function markdown(options) {
+  return returnWidget(
+    { widget: "markdown" },
+    options
+  );
+}
+export function code(options) {
+  return returnWidget({ widget: "code" }, options);
+}
+export function color(options) {
+  return returnWidget(
+    { widget: "color" },
+    options
+  );
+}
+export function dateTime(options) {
+  return returnWidget(
+    { widget: "datetime" },
+    options
+  );
+}
+export function hidden(options) {
+  return returnWidget(
+    { widget: "hidden" },
+    options
+  );
+}
+export function list(options) {
+  return (id, ctx) => {
+    return object(
+      { ...options, widget: "list", fields: options.fields }
+    )(id, ctx);
+  };
+}
+export function map(options) {
+  return returnWidget({ widget: "map" }, options);
+}
+export function number(options) {
+  return returnWidget(
+    { widget: "number" },
+    options
+  );
+}
+export function object(options) {
+  return (id, ctx) => {
+    const _fields = mapObjIndexed((buildField, id2) => {
+      return buildField(id2, ctx);
+    }, options.fields);
+    return {
+      name: id,
+      widget: "object",
+      ...options,
+      fields: Object.values(_fields)
+    };
+  };
+}
+export function select(options) {
+  return returnWidget(
+    { widget: "select" },
+    options
+  );
+}
+export function text(options) {
+  return returnWidget({ widget: "text" }, options);
+}
+export function string(options) {
+  return returnWidget(
+    { widget: "string" },
+    options
+  );
+}
+export function relation(options) {
+  return returnWidget(
+    { widget: "relation" },
+    options
+  );
+}
+export function file(options) {
+  return returnWidget({ widget: "file" }, options);
+}
+export function image(options) {
+  return (name, ctx) => {
+    if (options?.media_folder)
+      options.media_folder = join(ctx?.rootDir || "/", options.media_folder);
+    return returnWidget(
+      { widget: "image" },
+      options
+    )(name, ctx);
+  };
+}
+export function imageV1(options) {
+  return (name, ctx) => {
+    if (options?.media_folder)
+      options.media_folder = join(ctx?.rootDir || "/", options.media_folder);
+    return {
+      name,
+      widget: "object",
+      fields: [
+        returnWidget(
+          { widget: "image" },
+          options
+        )("src", ctx),
+        returnWidget(
+          { widget: "string" },
+          {
+            required: false
+          }
+        )("alt", {
+          ...ctx
+        }),
+        returnWidget(
+          { widget: "string" },
+          {
+            required: false
+          }
+        )("title", ctx)
+      ]
+    };
+  };
+}
+export function date(options) {
+  return returnWidget(
+    {
+      widget: "date"
+    },
+    options
+  );
+}
+export function custom(options) {
+  return returnWidget({}, options);
+}
+export const widgets = {
+  string,
+  color,
+  number,
+  custom,
+  hidden,
+  file,
+  date,
+  dateTime,
+  code,
+  image,
+  markdown,
+  object,
+  boolean,
+  imageV1,
+  list,
+  text,
+  map,
+  select,
+  relation
+};

package/modules/netlify-cms/server/lib/composables.d.ts

@@ -0,0 +1,28 @@
+import type { AllCollections } from './cms/helpers';
+import type { AllWidgets } from './cms/widgets';
+import type { Collections, DefineMethod } from './types';
+type Group = 'pages' | 'posts' | 'collections' | 'settings';
+interface Ctx {
+    widgets: AllWidgets;
+    collections: AllCollections;
+    utils: any;
+    dir: string;
+}
+export interface OptionsCollection {
+    dir: string;
+    group: Group;
+    injectContext?: {
+        page: string;
+        assign: string;
+    };
+    setup: (ctx: Ctx) => (localeDir: string) => DefineMethod<Collections.Files | Collections.Folder>;
+}
+export declare function defineCmsCollection(options: OptionsCollection): (ctx: Ctx) => (baseDir: string, ctx2: any) => {
+    group: Group;
+    folder: string;
+    fields: import("./types").Cms.Fields[];
+} | {
+    group: Group;
+    files: Collections.File[];
+};
+export {};