@monkeyplus/flow 6.0.16 → 6.0.18

package/modules/cms/server/api/localFs.mjs

@@ -0,0 +1,88 @@
+import { Buffer } from "node:buffer";
+import path from "node:path";
+import fs from "fs-extra";
+import { defineEventHandler, getQuery, readBody } from "nitro/h3";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { listFiles } from "../lib/fs.mjs";
+const baseUrl = "/api/repos/local/";
+export default defineEventHandler(async (event) => {
+  const pathname = event.url.pathname.replace(baseUrl, "");
+  const config = useRuntimeConfig()?.flow?.cms;
+  console.log("runtimeConfig", config);
+  const [_repo, command, ...rest] = pathname.split("/");
+  if (command === "blobs") {
+    const query = getQuery(event);
+    if (query.update) {
+      const body = await readBody(event);
+      const data = Buffer.from(body?.content || "", "base64").toString("utf-8");
+      console.log(query.update, config.base);
+      const filePath = path.relative(config.base, decodeURIComponent(query.update).trim());
+      console.log("updatePath", filePath);
+      await fs.writeFile(filePath, data, "utf-8");
+      return {
+        sha: ""
+      };
+    }
+    if (query.create) {
+      const body = await readBody(event);
+      let data = Buffer.from(body?.content || "", "base64");
+      if (!query.isFile) {
+        data = data.toString("utf-8");
+      }
+      const createPath = decodeURIComponent(query.create);
+      const filePath = path.relative(config.base, createPath);
+      fs.ensureFileSync(filePath);
+      await fs.writeFile(filePath, data, "utf-8");
+      return {
+        sha: ""
+      };
+    }
+    const [sha] = rest;
+    const blobPath = Buffer.from(sha, "base64").toString();
+    if (blobPath.endsWith(".json")) {
+      const file = await fs.readFile(blobPath, "utf-8");
+      return {
+        file: {
+          encoding: "json",
+          content: JSON.parse(file || "{}")
+        }
+      };
+    } else {
+      const content = await fs.readFile(blobPath);
+      return {
+        file: {
+          encoding: "base64",
+          content: Buffer.from(content).toString("base64")
+        }
+      };
+    }
+  }
+  if (command === "branches") {
+    return {};
+  }
+  if (command === "commits") {
+    return {};
+  }
+  if (command === "files") {
+    const { folder, file } = getQuery(event);
+    if (file) {
+      const filePath = path.relative(config.base, decodeURIComponent(file));
+      console.log("file", file, config.base, filePath);
+      const content = await fs.readFile(filePath, "utf-8");
+      return {
+        content: JSON.parse(content),
+        encoding: "json"
+      };
+    }
+    const folderPath = path.relative(config.base, folder);
+    const files = await listFiles(folderPath, "", 1);
+    return { files: files.map((f) => {
+      return {
+        path: path.basename(f),
+        sha: Buffer.from(f).toString("base64")
+      };
+    }) };
+  }
+  if (command === "refs") {
+  }
+});

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

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

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

@@ -0,0 +1,12 @@
+import { defineEventHandler } from "nitro/h3";
+import { useRuntimeConfig } from "nitro/runtime-config";
+export default defineEventHandler(async () => {
+  const runtimeConfig = useRuntimeConfig();
+  return {
+    locale: runtimeConfig?.flow?.locale || {},
+    base: runtimeConfig?.flow?.cms?.base || "",
+    branch: runtimeConfig?.flow?.cms?.branch || "master",
+    mediaFolder: runtimeConfig?.flow?.cms?.mediaFolder || "media",
+    publicFolder: runtimeConfig?.flow?.cms?.publicFolder || "public"
+  };
+});

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

@@ -0,0 +1,116 @@
+import type { AllCollections } from './helpers';
+import type { CollectionsFiles, CollectionsFolder, DefineMethod } from './types';
+import type { AllWidgets } from './widgets';
+interface Ctx {
+    widgets: AllWidgets;
+    collections: AllCollections;
+    utils: any;
+    dir: string;
+}
+export interface OptionsCollectionFiles {
+    dir: string;
+    preview?: {
+        pageName?: string;
+    };
+    setup: (ctx: Ctx) => (localeDir: string) => DefineMethod<CollectionsFiles>;
+}
+export interface OptionsCollectionFolder {
+    dir: string;
+    preview?: {
+        pageName?: string;
+        url?: string;
+    };
+    setup: (ctx: Ctx) => (localeDir: string) => DefineMethod<CollectionsFolder>;
+}
+export declare function defineCmsPage(options: OptionsCollectionFiles): (ctx: Ctx) => (baseDir: string, ctx2: any) => {
+    group: string;
+    preview: {
+        pageName?: string;
+    } | undefined;
+    name: string;
+    label: string;
+    flow?: {
+        url?: string | undefined;
+        locale?: any;
+    } | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    extension?: string;
+    files: import("./types").CollectionsFile[];
+};
+export declare function defineCmsPages(options: OptionsCollectionFolder): (ctx: Ctx) => (baseDir: string, ctx2: any) => {
+    group: string;
+    preview: {
+        pageName?: string;
+        url?: string;
+    } | undefined;
+    name: string;
+    label: string;
+    flow?: {
+        url?: string | undefined;
+        locale?: any;
+    } | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    extension?: string;
+    folder: string;
+    fields: import("./types").CmsFields[];
+};
+export declare function defineCmsPosts(options: OptionsCollectionFolder): (ctx: Ctx) => (baseDir: string, ctx2: any) => {
+    group: string;
+    preview: {
+        pageName?: string;
+        url?: string;
+    } | undefined;
+    name: string;
+    label: string;
+    flow?: {
+        url?: string | undefined;
+        locale?: any;
+    } | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    extension?: string;
+    folder: string;
+    fields: import("./types").CmsFields[];
+};
+export declare function defineCmsItems(options: OptionsCollectionFolder): (ctx: Ctx) => (baseDir: string, ctx2: any) => {
+    group: string;
+    preview: {
+        pageName?: string;
+        url?: string;
+    } | undefined;
+    name: string;
+    label: string;
+    flow?: {
+        url?: string | undefined;
+        locale?: any;
+    } | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    extension?: string;
+    folder: string;
+    fields: import("./types").CmsFields[];
+};
+export declare function defineCmsSettings(options: OptionsCollectionFiles): (ctx: Ctx) => (baseDir: string, ctx2: any) => {
+    group: string;
+    preview: {
+        pageName?: string;
+    } | undefined;
+    name: string;
+    label: string;
+    flow?: {
+        url?: string | undefined;
+        locale?: any;
+    } | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    extension?: string;
+    files: import("./types").CollectionsFile[];
+};
+export {};

package/modules/cms/server/lib/composables.mjs

@@ -0,0 +1,82 @@
+import { join } from "node:path";
+export function defineCmsPage(options) {
+  return (ctx) => {
+    const setupFn = options.setup(ctx);
+    const group = "pages";
+    const collectionFn = setupFn(join(group, options.dir));
+    return (baseDir, ctx2) => {
+      const collection = collectionFn(baseDir, ctx2);
+      return {
+        ...collection,
+        group,
+        preview: options.preview
+        // injectContext: options.injectContext,
+      };
+    };
+  };
+}
+export function defineCmsPages(options) {
+  return (ctx) => {
+    const setupFn = options.setup(ctx);
+    const group = "pages";
+    const collectionFn = setupFn(join(group, options.dir));
+    return (baseDir, ctx2) => {
+      const collection = collectionFn(baseDir, ctx2);
+      return {
+        ...collection,
+        group,
+        preview: options.preview
+        // injectContext: options.injectContext,
+      };
+    };
+  };
+}
+export function defineCmsPosts(options) {
+  return (ctx) => {
+    const setupFn = options.setup(ctx);
+    const group = "posts";
+    console.log("preview...", options.preview);
+    const collectionFn = setupFn(join(group, options.dir));
+    return (baseDir, ctx2) => {
+      const collection = collectionFn(baseDir, ctx2);
+      return {
+        ...collection,
+        group,
+        preview: options.preview
+        // injectContext: options.injectContext,
+      };
+    };
+  };
+}
+export function defineCmsItems(options) {
+  return (ctx) => {
+    const setupFn = options.setup(ctx);
+    const group = "items";
+    const collectionFn = setupFn(join(group, options.dir));
+    return (baseDir, ctx2) => {
+      const collection = collectionFn(baseDir, ctx2);
+      return {
+        ...collection,
+        group,
+        preview: options.preview
+        // injectContext: options.injectContext,
+      };
+    };
+  };
+}
+export function defineCmsSettings(options) {
+  return (ctx) => {
+    const setupFn = options.setup(ctx);
+    const group = "settings";
+    const collectionFn = setupFn(join(group, options.dir));
+    return (baseDir, ctx2) => {
+      const collection = collectionFn(baseDir, ctx2);
+      return {
+        ...collection,
+        group,
+        preview: options.preview
+        // inject   Context: options.injectContext,
+      };
+    };
+  };
+}

package/modules/cms/server/lib/fs.d.ts

@@ -0,0 +1 @@
+export declare function listFiles(dir: string, extension: string, depth: number): Promise<string[]>;

package/modules/cms/server/lib/fs.mjs

@@ -0,0 +1,18 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function listFiles(dir, extension, depth) {
+  if (depth <= 0)
+    return [];
+  try {
+    const dirents = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(
+      dirents.map((dirent) => {
+        const res = path.join(dir, dirent.name);
+        return dirent.isDirectory() ? listFiles(res, extension, depth - 1) : [res].filter((f) => f.endsWith(extension));
+      })
+    );
+    return [].concat(...files);
+  } catch (e) {
+    return [];
+  }
+}

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

@@ -0,0 +1,14 @@
+import type { CollectionFolderId, Collections_Base, CollectionsFile, CollectionsFolder, DefineCms, DefineMethod, DefineMethodExtend, HelpersCollectionFiles, ModelFields } 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: ModelFields;
+}): DefineMethodExtend<CollectionsFile>;
+declare function collectionFolder(base: CollectionFolderId): (dir: string) => DefineMethod<CollectionsFolder>;
+export declare const collections: {
+    folder: typeof collectionFolder;
+    files: HelpersCollectionFiles;
+    file: typeof collectionFile;
+};
+export type AllCollections = typeof collections;
+export declare const defineCms: DefineCms;
+export {};

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

@@ -0,0 +1,78 @@
+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),
+      preview: base.preview
+    };
+  };
+}
+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),
+      preview: base.preview
+      // 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/cms/server/lib/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Widgets
+ */
+interface WidgetBase {
+    name: string;
+    label: string;
+    required?: boolean | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    default?: any;
+    hint?: string;
+}
+export type WidgetColor = WidgetBase & {
+    widget: 'color';
+};
+export type WidgetBoolean = WidgetBase & {
+    widget: 'boolean';
+};
+export type WidgetEditor = WidgetBase & {
+    widget: 'editor';
+};
+export type WidgetText = WidgetBase & {
+    widget: 'text';
+};
+export type WidgetString = WidgetBase & {
+    widget: 'string';
+};
+export type WidgetFile = WidgetBase & {
+    widget: 'file';
+};
+export type WidgetSelect = WidgetBase & {
+    widget: 'select';
+    items: (string | {
+        label: string;
+        value: string;
+    })[];
+    searchable?: boolean;
+};
+export type WidgetObject = WidgetBase & {
+    widget: 'object';
+    fields: CmsFields[];
+    collapsed?: boolean;
+};
+export type WidgetList = WidgetBase & {
+    widget: 'list';
+    fields: CmsFields[];
+    collapsed?: boolean;
+};
+export type WidgetImage = WidgetBase & {
+    widget: 'image';
+    mediaFolder?: string;
+};
+export type WidgetDate = WidgetBase & {
+    widget: 'date';
+};
+export type WidgetNumber = WidgetBase & {
+    widget: 'number';
+};
+/**
+ * CMS
+ */
+type CmsConfig = any;
+export type CmsFields = WidgetString | WidgetSelect | WidgetText | WidgetBoolean | WidgetList | WidgetObject | WidgetColor | WidgetImage | WidgetDate | WidgetNumber | WidgetEditor | WidgetFile;
+/**
+ * COLLECTION
+ *
+ */
+export interface Collections_Base {
+    name: string;
+    label: string;
+    flow?: {
+        url?: string | undefined;
+        locale?: any;
+    } | undefined;
+    options?: {
+        [x: string]: any;
+    } | undefined;
+    extension?: string;
+    preview?: {
+        pageName: string;
+    };
+}
+export type CollectionsFolder = Collections_Base & {
+    folder: string;
+    fields: CmsFields[];
+};
+export type CollectionsFiles = Collections_Base & {
+    files: CollectionsFile[];
+};
+export interface CollectionsFile {
+    fields: CmsFields[];
+    label: string;
+    name: string;
+    file: string;
+}
+export interface ContextWidget {
+    rootDir: string;
+}
+/**
+ * HELPERS
+ */
+export type ModelFields = Record<string, (parentName: string, ctx: ContextWidget) => CmsFields>;
+export type DefineMethod<R> = (parentName: string, ctx: ContextWidget) => R;
+export type DefineCms = (options: Omit<CmsConfig, 'collections'>, collections: DefineMethod<CollectionsFiles | CollectionsFolder>[]) => (dir: string, ctx: ContextWidget) => CmsConfig;
+/**
+ * Helpers
+ */
+export type DefineMethodExtend<R> = (id: string) => (parentName: string, ctx: ContextWidget) => R;
+export type DefineFile = Record<string, DefineMethodExtend<CollectionsFile>>;
+export interface CollectionFileId extends Omit<Collections_Base, 'name'> {
+    files: DefineFile;
+}
+export interface CollectionFolderId extends Omit<CollectionsFolder, 'name' | 'folder' | 'fields'> {
+    fields: ModelFields;
+}
+export interface HelpersCollectionFiles {
+    (base: CollectionFileId): (baseDir: string) => DefineMethod<CollectionsFiles>;
+}
+export {};

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

@@ -0,0 +1,82 @@
+import type { ContextWidget, ModelFields, WidgetBoolean, WidgetColor, WidgetDate, WidgetEditor, WidgetFile, WidgetImage, WidgetList, WidgetNumber, WidgetObject, WidgetSelect, WidgetString, WidgetText } 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<WidgetBoolean, 'widget' | 'name'>): BuildWidget<WidgetBoolean>;
+/**
+ * editor
+ */
+export declare function editor(options?: Omit<WidgetEditor, 'widget' | 'name'>): BuildWidget<WidgetEditor>;
+/**
+ * Color
+ */
+export declare function color(options?: WidgetInput<WidgetColor>): BuildWidget<WidgetColor>;
+/**
+ * DateTime
+ */
+export declare function dateTime(options?: Omit<WidgetDate, 'widget' | 'name'>): BuildWidget<WidgetDate>;
+/**
+ * List
+ */
+export declare function list(options: Omit<WidgetList, 'widget' | 'name' | 'fields'> & {
+    fields: ModelFields;
+}): BuildWidget<WidgetList>;
+/**
+ * Number
+ */
+export declare function number(options: Omit<WidgetNumber, 'widget' | 'name'>): BuildWidget<WidgetNumber>;
+/**
+ * Object
+ */
+export declare function object(options: Omit<WidgetObject, 'widget' | 'name' | 'fields'> & {
+    fields: ModelFields;
+}): BuildWidget<WidgetObject>;
+/**
+ * Select
+ */
+export declare function select(options: Omit<WidgetSelect, 'widget' | 'name'>): BuildWidget<WidgetSelect>;
+/**
+ * Text
+ */
+export declare function text(options: Omit<WidgetText, 'widget' | 'name'>): BuildWidget<WidgetText>;
+/**
+ * String
+ */
+export declare function string(options?: WidgetInput<WidgetString>): BuildWidget<WidgetString>;
+/**
+ * File
+ */
+export declare function file(options?: WidgetInput<WidgetFile>): BuildWidget<WidgetFile>;
+export declare function image(options?: WidgetInput<WidgetImage>): BuildWidget<WidgetImage>;
+/**
+ * Image
+ */
+export declare function imageObject(options?: WidgetInput<WidgetImage>): BuildWidget<WidgetObject>;
+/**
+ * LinkOrButton
+ */
+export declare function link(options?: WidgetInput<Partial<WidgetObject>>): BuildWidget<WidgetObject>;
+/**
+ *****************************************
+ */
+export declare const widgets: {
+    string: typeof string;
+    color: typeof color;
+    number: typeof number;
+    file: typeof file;
+    dateTime: typeof dateTime;
+    image: typeof image;
+    editor: typeof editor;
+    object: typeof object;
+    boolean: typeof boolean;
+    list: typeof list;
+    text: typeof text;
+    select: typeof select;
+    imageObject: typeof imageObject;
+    link: typeof link;
+};
+export type AllWidgets = typeof widgets;