@gravito/monolith 1.0.0-beta.1 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @gravito/monolith
+
+## 1.0.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @gravito/core@1.0.0
+  - @gravito/mass@1.0.0

package/README.md

@@ -14,7 +14,7 @@ bun add @gravito/monolith
 
 1.  **Register the Orbit**:
     ```typescript
-    import { PlanetCore } from 'gravito-core';
+    import { PlanetCore } from '@gravito/core';
     import { OrbitContent } from '@gravito/monolith';
 
     const core = new PlanetCore();

package/README.zh-TW.md

@@ -11,7 +11,7 @@ bun add @gravito/monolith
 ## 快速開始
 
 ```typescript
-import { PlanetCore } from 'gravito-core'
+import { PlanetCore } from '@gravito/core'
 import { OrbitContent } from '@gravito/monolith'
 
 const core = new PlanetCore()

package/dist/index.cjs

@@ -0,0 +1,428 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseController: () => BaseController,
+  ContentManager: () => ContentManager,
+  Controller: () => Controller,
+  FormRequest: () => FormRequest,
+  OrbitMonolith: () => OrbitMonolith,
+  Route: () => RouterHelper,
+  Schema: () => import_mass2.Schema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ContentManager.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_marked = require("marked");
+var ContentManager = class {
+  /**
+   * Create a new ContentManager instance.
+   *
+   * @param rootDir - The root directory of the application.
+   */
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  collections = /* @__PURE__ */ new Map();
+  // Simple memory cache: collection:locale:slug -> ContentItem
+  cache = /* @__PURE__ */ new Map();
+  renderer = (() => {
+    const renderer = new import_marked.marked.Renderer();
+    renderer.html = (html) => this.escapeHtml(html);
+    renderer.link = (href, title, text) => {
+      if (!href || !this.isSafeUrl(href)) {
+        return text;
+      }
+      const safeHref = this.escapeHtml(href);
+      const titleAttr = title ? ` title="${this.escapeHtml(title)}"` : "";
+      return `<a href="${safeHref}"${titleAttr}>${text}</a>`;
+    };
+    return renderer;
+  })();
+  /**
+   * Register a new content collection.
+   *
+   * @param name - The name of the collection.
+   * @param config - The collection configuration.
+   */
+  defineCollection(name, config) {
+    this.collections.set(name, config);
+  }
+  /**
+   * Find a single content item.
+   *
+   * @param collectionName - The collection name (e.g. 'docs').
+   * @param slug - The file slug (e.g. 'installation').
+   * @param locale - The locale (e.g. 'en'). Defaults to 'en'.
+   * @returns A promise resolving to the ContentItem or null if not found.
+   * @throws {Error} If the collection is not defined.
+   */
+  async find(collectionName, slug, locale = "en") {
+    const config = this.collections.get(collectionName);
+    if (!config) {
+      throw new Error(`Collection '${collectionName}' not defined`);
+    }
+    const safeSlug = this.sanitizeSegment(slug);
+    const safeLocale = this.sanitizeSegment(locale);
+    if (!safeSlug || !safeLocale) {
+      return null;
+    }
+    const cacheKey = `${collectionName}:${locale}:${slug}`;
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const filePath = (0, import_node_path.join)(this.rootDir, config.path, safeLocale, `${safeSlug}.md`);
+    try {
+      const exists = await (0, import_promises.stat)(filePath).then(() => true).catch(() => false);
+      if (!exists) {
+        return null;
+      }
+      const fileContent = await (0, import_promises.readFile)(filePath, "utf-8");
+      const { data, content, excerpt } = (0, import_gray_matter.default)(fileContent);
+      const html = await import_marked.marked.parse(content, { renderer: this.renderer });
+      const item = {
+        slug,
+        body: html,
+        meta: data,
+        raw: content,
+        excerpt
+      };
+      this.cache.set(cacheKey, item);
+      return item;
+    } catch (e) {
+      console.error(`[Orbit-Content] Error reading file: ${filePath}`, e);
+      return null;
+    }
+  }
+  /**
+   * List all items in a collection for a locale.
+   * Useful for generating sitemaps or index pages.
+   *
+   * @param collectionName - The collection name.
+   * @param locale - The locale. Defaults to 'en'.
+   * @returns A promise resolving to an array of ContentItems.
+   * @throws {Error} If the collection is not defined.
+   */
+  async list(collectionName, locale = "en") {
+    const config = this.collections.get(collectionName);
+    if (!config) {
+      throw new Error(`Collection '${collectionName}' not defined`);
+    }
+    const safeLocale = this.sanitizeSegment(locale);
+    if (!safeLocale) {
+      return [];
+    }
+    const dirPath = (0, import_node_path.join)(this.rootDir, config.path, safeLocale);
+    try {
+      const files = await (0, import_promises.readdir)(dirPath);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".md")) {
+          continue;
+        }
+        const slug = (0, import_node_path.parse)(file).name;
+        const item = await this.find(collectionName, slug, safeLocale);
+        if (item) {
+          items.push(item);
+        }
+      }
+      return items;
+    } catch (_e) {
+      return [];
+    }
+  }
+  sanitizeSegment(value) {
+    if (!value) {
+      return null;
+    }
+    if (value.includes("\0")) {
+      return null;
+    }
+    if (value.includes("/") || value.includes("\\")) {
+      return null;
+    }
+    if (value.includes("..")) {
+      return null;
+    }
+    return value;
+  }
+  escapeHtml(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  }
+  isSafeUrl(href) {
+    const trimmed = href.trim();
+    if (!trimmed) {
+      return false;
+    }
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith("javascript:") || lower.startsWith("vbscript:") || lower.startsWith("data:")) {
+      return false;
+    }
+    const schemeMatch = lower.match(/^[a-z][a-z0-9+.-]*:/);
+    if (!schemeMatch) {
+      return true;
+    }
+    const scheme = schemeMatch[0];
+    return scheme === "http:" || scheme === "https:" || scheme === "mailto:";
+  }
+};
+
+// src/index.ts
+var import_mass2 = require("@gravito/mass");
+
+// src/Sanitizer.ts
+var Sanitizer = class {
+  /**
+   * Recursively trim strings and convert empty strings to null.
+   */
+  static clean(data) {
+    if (!data || typeof data !== "object") {
+      return data;
+    }
+    const cleaned = Array.isArray(data) ? [] : {};
+    for (const key in data) {
+      let value = data[key];
+      if (typeof value === "string") {
+        value = value.trim();
+        if (value === "") {
+          value = null;
+        }
+      } else if (typeof value === "object" && value !== null) {
+        value = this.clean(value);
+      }
+      cleaned[key] = value;
+    }
+    return cleaned;
+  }
+};
+
+// src/Controller.ts
+var BaseController = class {
+  sanitizer = new Sanitizer();
+  async call(ctx, method) {
+    const action = this[method];
+    if (typeof action !== "function") {
+      throw new Error(`Method ${method} not found on controller`);
+    }
+    return await action.apply(this, [ctx]);
+  }
+};
+var Controller = class {
+  context;
+  /**
+   * Set the request context for this controller instance.
+   */
+  setContext(context) {
+    this.context = context;
+    return this;
+  }
+  /**
+   * Return a JSON response.
+   */
+  json(data, status = 200) {
+    return this.context.json(data, status);
+  }
+  /**
+   * Return a text response.
+   */
+  text(text, status = 200) {
+    return this.context.text(text, status);
+  }
+  /**
+   * Redirect to a given URL.
+   */
+  redirect(url, status = 302) {
+    return this.context.redirect(url, status);
+  }
+  /**
+   * Get an item from the context variables.
+   */
+  get(key) {
+    return this.context.get(key);
+  }
+  /**
+   * Get the request object.
+   */
+  get request() {
+    return this.context.req;
+  }
+  /**
+   * Validate the request against a schema.
+   */
+  async validate(_schema, source = "json") {
+    const req = this.context.req;
+    return req.valid(source);
+  }
+  /**
+   * Resolve a controller action into a handler compatible with GravitoContext.
+   */
+  static call(method) {
+    return async (c) => {
+      const instance = new this();
+      instance.setContext(c);
+      const action = instance[method];
+      return action.apply(instance, [c]);
+    };
+  }
+};
+
+// src/FormRequest.ts
+var import_mass = require("@gravito/mass");
+var FormRequest = class {
+  context;
+  /**
+   * Define the source of data (json, query, form, etc.).
+   */
+  source() {
+    return "json";
+  }
+  /**
+   * Determine if the user is authorized to make this request.
+   */
+  authorize() {
+    return true;
+  }
+  /**
+   * Set the context.
+   */
+  setContext(context) {
+    this.context = context;
+    return this;
+  }
+  /**
+   * Get the validated data.
+   */
+  validated() {
+    const data = this.context.req.valid(this.source());
+    return Sanitizer.clean(data);
+  }
+  /**
+   * Static helper to create a middleware from this request class.
+   */
+  static middleware() {
+    const RequestClass = this;
+    return async (c, next) => {
+      const instance = new RequestClass();
+      instance.setContext(c);
+      if (!instance.authorize()) {
+        return c.json({ message: "This action is unauthorized." }, 403);
+      }
+      const validator = (0, import_mass.validate)(instance.source(), instance.schema(), (result, ctx) => {
+        if (!result.success) {
+          const errors = {};
+          const issues = result.error?.issues || [];
+          for (const issue of issues) {
+            const path = Array.isArray(issue.path) ? issue.path.join(".") : issue.path || "root";
+            const key = path.replace(/^\//, "").replace(/\//g, ".");
+            if (!errors[key]) errors[key] = [];
+            errors[key].push(issue.message || "Validation failed");
+          }
+          return ctx.json(
+            {
+              message: "The given data was invalid.",
+              errors: Object.keys(errors).length > 0 ? errors : { root: ["Validation failed"] }
+            },
+            422
+          );
+        }
+      });
+      return validator(c, next);
+    };
+  }
+};
+
+// src/Router.ts
+var RouterHelper = class {
+  /**
+   * Register standard resource routes for a controller.
+   *
+   * GET    /prefix          -> index
+   * GET    /prefix/create   -> create
+   * POST   /prefix          -> store
+   * GET    /prefix/:id      -> show
+   * GET    /prefix/:id/edit -> edit
+   * PUT    /prefix/:id      -> update
+   * DELETE /prefix/:id      -> destroy
+   */
+  static resource(app, prefix, controller) {
+    const p = prefix.startsWith("/") ? prefix : `/${prefix}`;
+    const routes = {
+      index: ["get", ""],
+      create: ["get", "/create"],
+      store: ["post", ""],
+      show: ["get", "/:id"],
+      edit: ["get", "/:id/edit"],
+      update: ["put", "/:id"],
+      destroy: ["delete", "/:id"]
+    };
+    for (const [method, [verb, suffix]] of Object.entries(routes)) {
+      if (typeof controller.prototype[method] === "function") {
+        ;
+        app[verb](`${p}${suffix}`, controller.call(method));
+      }
+    }
+  }
+};
+
+// src/index.ts
+var OrbitMonolith = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  install(core) {
+    const root = this.config.root || process.cwd();
+    const manager = new ContentManager(root);
+    if (this.config.collections) {
+      for (const [name, config] of Object.entries(this.config.collections)) {
+        manager.defineCollection(name, config);
+      }
+    }
+    core.adapter.use("*", async (c, next) => {
+      c.set("content", manager);
+      await next();
+      return void 0;
+    });
+    core.logger.info("Orbit Monolith installed \u2B1B\uFE0F");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseController,
+  ContentManager,
+  Controller,
+  FormRequest,
+  OrbitMonolith,
+  Route,
+  Schema
+});

package/dist/index.d.cts

@@ -0,0 +1,168 @@
+import * as _gravito_core from '@gravito/core';
+import { GravitoContext, GravitoOrbit, PlanetCore } from '@gravito/core';
+import { TSchema } from '@gravito/mass';
+export { Schema } from '@gravito/mass';
+import { Hono } from 'hono';
+
+interface ContentItem {
+    slug: string;
+    body: string;
+    excerpt?: string;
+    meta: Record<string, any>;
+    raw: string;
+}
+interface CollectionConfig {
+    path: string;
+}
+declare class ContentManager {
+    private rootDir;
+    private collections;
+    private cache;
+    private renderer;
+    /**
+     * Create a new ContentManager instance.
+     *
+     * @param rootDir - The root directory of the application.
+     */
+    constructor(rootDir: string);
+    /**
+     * Register a new content collection.
+     *
+     * @param name - The name of the collection.
+     * @param config - The collection configuration.
+     */
+    defineCollection(name: string, config: CollectionConfig): void;
+    /**
+     * Find a single content item.
+     *
+     * @param collectionName - The collection name (e.g. 'docs').
+     * @param slug - The file slug (e.g. 'installation').
+     * @param locale - The locale (e.g. 'en'). Defaults to 'en'.
+     * @returns A promise resolving to the ContentItem or null if not found.
+     * @throws {Error} If the collection is not defined.
+     */
+    find(collectionName: string, slug: string, locale?: string): Promise<ContentItem | null>;
+    /**
+     * List all items in a collection for a locale.
+     * Useful for generating sitemaps or index pages.
+     *
+     * @param collectionName - The collection name.
+     * @param locale - The locale. Defaults to 'en'.
+     * @returns A promise resolving to an array of ContentItems.
+     * @throws {Error} If the collection is not defined.
+     */
+    list(collectionName: string, locale?: string): Promise<ContentItem[]>;
+    private sanitizeSegment;
+    private escapeHtml;
+    private isSafeUrl;
+}
+
+/**
+ * Utility to clean up request data.
+ */
+declare class Sanitizer {
+    /**
+     * Recursively trim strings and convert empty strings to null.
+     */
+    static clean(data: any): any;
+}
+
+declare abstract class BaseController {
+    protected sanitizer: Sanitizer;
+    call(ctx: GravitoContext, method: string): Promise<Response>;
+}
+declare abstract class Controller {
+    protected context: GravitoContext;
+    /**
+     * Set the request context for this controller instance.
+     */
+    setContext(context: GravitoContext): this;
+    /**
+     * Return a JSON response.
+     */
+    protected json(data: any, status?: number): Response;
+    /**
+     * Return a text response.
+     */
+    protected text(text: string, status?: number): Response;
+    /**
+     * Redirect to a given URL.
+     */
+    protected redirect(url: string, status?: number): Response;
+    /**
+     * Get an item from the context variables.
+     */
+    protected get(key: string): any;
+    /**
+     * Get the request object.
+     */
+    protected get request(): _gravito_core.GravitoRequest;
+    /**
+     * Validate the request against a schema.
+     */
+    protected validate(_schema: any, source?: 'json' | 'query' | 'form'): Promise<any>;
+    /**
+     * Resolve a controller action into a handler compatible with GravitoContext.
+     */
+    static call(method: string): any;
+}
+
+declare abstract class FormRequest {
+    protected context: GravitoContext;
+    /**
+     * Define the validation schema.
+     */
+    abstract schema(): TSchema;
+    /**
+     * Define the source of data (json, query, form, etc.).
+     */
+    source(): 'json' | 'query' | 'form';
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    authorize(): boolean;
+    /**
+     * Set the context.
+     */
+    setContext(context: GravitoContext): this;
+    /**
+     * Get the validated data.
+     */
+    validated(): any;
+    /**
+     * Static helper to create a middleware from this request class.
+     */
+    static middleware(): any;
+}
+
+declare class RouterHelper {
+    /**
+     * Register standard resource routes for a controller.
+     *
+     * GET    /prefix          -> index
+     * GET    /prefix/create   -> create
+     * POST   /prefix          -> store
+     * GET    /prefix/:id      -> show
+     * GET    /prefix/:id/edit -> edit
+     * PUT    /prefix/:id      -> update
+     * DELETE /prefix/:id      -> destroy
+     */
+    static resource(app: Hono<any, any, any>, prefix: string, controller: any): void;
+}
+
+declare module '@gravito/core' {
+    interface Variables {
+        content: ContentManager;
+    }
+}
+interface ContentConfig {
+    root?: string;
+    collections?: Record<string, CollectionConfig>;
+}
+declare class OrbitMonolith implements GravitoOrbit {
+    private config;
+    constructor(config?: ContentConfig);
+    install(core: PlanetCore): void;
+}
+
+export { BaseController, type CollectionConfig, type ContentConfig, type ContentItem, ContentManager, Controller, FormRequest, OrbitMonolith, RouterHelper as Route };