@dyrected/core 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# @dyrected/core
+
+This is the core package/app for the Dyrected ecosystem.

package/dist/index.d.mts

@@ -0,0 +1,265 @@
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+type FieldType = 'text' | 'textarea' | 'richText' | 'number' | 'boolean' | 'date' | 'select' | 'multiSelect' | 'email' | 'url' | 'relationship' | 'array' | 'object' | 'json' | 'blocks';
+interface Block {
+    slug: string;
+    labels?: {
+        singular: string;
+        plural: string;
+    };
+    fields: Field[];
+}
+interface Field {
+    name: string;
+    type: FieldType;
+    label?: string;
+    required?: boolean;
+    unique?: boolean;
+    defaultValue?: any;
+    options?: string[] | {
+        label: string;
+        value: string;
+    }[];
+    collection?: string;
+    fields?: Field[];
+    blocks?: Block[];
+    access?: {
+        read?: AccessFunction;
+        update?: AccessFunction;
+    };
+    hooks?: {
+        beforeChange?: FieldHook[];
+        afterRead?: FieldHook[];
+    };
+    admin?: {
+        placeholder?: string;
+        description?: string;
+        hidden?: boolean;
+        readOnly?: boolean;
+        condition?: (data: any) => boolean;
+    };
+}
+type AccessFunction = (args: {
+    user: any;
+    doc?: any;
+    data?: any;
+    req: any;
+}) => boolean | object | Promise<boolean | object>;
+type HookFunction = (args: {
+    data?: any;
+    doc?: any;
+    user?: any;
+    req?: any;
+}) => any | Promise<any>;
+type FieldHook = (args: {
+    value: any;
+    originalDoc?: any;
+    data?: any;
+    user?: any;
+}) => any | Promise<any>;
+interface CollectionConfig {
+    slug: string;
+    labels?: {
+        singular: string;
+        plural: string;
+    };
+    auth?: boolean;
+    upload?: boolean | UploadConfig;
+    fields: Field[];
+    access?: {
+        read?: AccessFunction;
+        create?: AccessFunction;
+        update?: AccessFunction;
+        delete?: AccessFunction;
+    };
+    hooks?: {
+        beforeRead?: HookFunction[];
+        afterRead?: HookFunction[];
+        beforeChange?: HookFunction[];
+        afterChange?: HookFunction[];
+        beforeDelete?: HookFunction[];
+        afterDelete?: HookFunction[];
+    };
+    admin?: {
+        useAsTitle?: string;
+        defaultColumns?: string[];
+        group?: string;
+        hidden?: boolean;
+    };
+}
+interface UploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    imageSizes?: {
+        name: string;
+        width: number;
+        height: number;
+        crop?: string;
+    }[];
+}
+interface GlobalConfig {
+    slug: string;
+    label?: string;
+    fields: Field[];
+    access?: {
+        read?: AccessFunction;
+        update?: AccessFunction;
+    };
+    hooks?: {
+        beforeRead?: HookFunction[];
+        afterRead?: HookFunction[];
+        beforeChange?: HookFunction[];
+        afterChange?: HookFunction[];
+    };
+    admin?: {
+        group?: string;
+        hidden?: boolean;
+    };
+}
+interface PaginatedResult<T = any> {
+    docs: T[];
+    total: number;
+    limit: number;
+    page: number;
+}
+interface DatabaseAdapter {
+    find(args: {
+        collection: string;
+        where?: any;
+        limit?: number;
+        page?: number;
+        sort?: string;
+    }): Promise<PaginatedResult>;
+    findOne(args: {
+        collection: string;
+        id: string;
+    }): Promise<any>;
+    create(args: {
+        collection: string;
+        data: any;
+    }): Promise<any>;
+    update(args: {
+        collection: string;
+        id: string;
+        data: any;
+    }): Promise<any>;
+    delete(args: {
+        collection: string;
+        id: string;
+    }): Promise<any>;
+    getGlobal(args: {
+        slug: string;
+    }): Promise<any>;
+    updateGlobal(args: {
+        slug: string;
+        data: any;
+    }): Promise<any>;
+}
+interface FileData {
+    filename: string;
+    filesize?: number;
+    mimeType: string;
+    url: string;
+    width?: number;
+    height?: number;
+    type?: 'upload' | 'external';
+    provider?: string;
+    provider_metadata?: any;
+    [key: string]: any;
+}
+interface StorageAdapter {
+    upload(args: {
+        filename: string;
+        buffer: Buffer;
+        mimeType: string;
+    }): Promise<FileData>;
+    delete(args: {
+        filename: string;
+    }): Promise<void>;
+    getURL(args: {
+        filename: string;
+    }): string;
+}
+interface DyrectedConfig {
+    collections: CollectionConfig[];
+    globals: GlobalConfig[];
+    db: DatabaseAdapter;
+    storage?: StorageAdapter;
+    email?: {
+        provider: string;
+        apiKey?: string;
+        from: string;
+    };
+    redis?: {
+        url: string;
+    };
+    cors?: {
+        origins: string[];
+    };
+}
+
+interface DyrectedContext {
+    Variables: {
+        config: DyrectedConfig;
+        siteId?: string;
+    };
+}
+/**
+ * Create the main Dyrected Hono application.
+ */
+declare function createDyrectedApp(config: DyrectedConfig): Hono<DyrectedContext, hono_types.BlankSchema, "/">;
+
+declare class PopulationService {
+    private db;
+    private collections;
+    constructor(db: DatabaseAdapter, collections: CollectionConfig[]);
+    /**
+     * Recursively populate relationship fields in a document or array of documents.
+     */
+    populate(args: {
+        data: any;
+        fields: Field[];
+        currentDepth: number;
+        maxDepth: number;
+    }): Promise<any>;
+    /**
+     * Helper to populate a PaginatedResult
+     */
+    populateResult(result: PaginatedResult, fields: Field[], maxDepth: number): Promise<PaginatedResult>;
+}
+
+/**
+ * MediaService handles background tasks for media assets,
+ * such as extracting metadata from external URLs (YouTube/Vimeo).
+ */
+declare class MediaService {
+    /**
+     * Fetches metadata for a given URL.
+     * Supports YouTube and Vimeo.
+     */
+    static fetchMetadata(url: string): Promise<{
+        provider: string;
+        provider_id: string;
+        thumbnail: string;
+        embedUrl: string;
+        type: "video";
+    } | null>;
+    private static extractYoutubeId;
+    private static extractVimeoId;
+}
+
+/**
+ * Define a collection configuration with full type safety.
+ */
+declare function defineCollection(config: CollectionConfig): CollectionConfig;
+/**
+ * Define a global configuration with full type safety.
+ */
+declare function defineGlobal(config: GlobalConfig): GlobalConfig;
+/**
+ * Define the main Dyrected configuration.
+ */
+declare function defineConfig(config: DyrectedConfig): DyrectedConfig;
+
+export { type AccessFunction, type Block, type CollectionConfig, type DatabaseAdapter, type DyrectedConfig, type DyrectedContext, type Field, type FieldHook, type FieldType, type FileData, type GlobalConfig, type HookFunction, MediaService, type PaginatedResult, PopulationService, type StorageAdapter, type UploadConfig, createDyrectedApp, defineCollection, defineConfig, defineGlobal };

package/dist/index.d.ts

@@ -0,0 +1,265 @@
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+type FieldType = 'text' | 'textarea' | 'richText' | 'number' | 'boolean' | 'date' | 'select' | 'multiSelect' | 'email' | 'url' | 'relationship' | 'array' | 'object' | 'json' | 'blocks';
+interface Block {
+    slug: string;
+    labels?: {
+        singular: string;
+        plural: string;
+    };
+    fields: Field[];
+}
+interface Field {
+    name: string;
+    type: FieldType;
+    label?: string;
+    required?: boolean;
+    unique?: boolean;
+    defaultValue?: any;
+    options?: string[] | {
+        label: string;
+        value: string;
+    }[];
+    collection?: string;
+    fields?: Field[];
+    blocks?: Block[];
+    access?: {
+        read?: AccessFunction;
+        update?: AccessFunction;
+    };
+    hooks?: {
+        beforeChange?: FieldHook[];
+        afterRead?: FieldHook[];
+    };
+    admin?: {
+        placeholder?: string;
+        description?: string;
+        hidden?: boolean;
+        readOnly?: boolean;
+        condition?: (data: any) => boolean;
+    };
+}
+type AccessFunction = (args: {
+    user: any;
+    doc?: any;
+    data?: any;
+    req: any;
+}) => boolean | object | Promise<boolean | object>;
+type HookFunction = (args: {
+    data?: any;
+    doc?: any;
+    user?: any;
+    req?: any;
+}) => any | Promise<any>;
+type FieldHook = (args: {
+    value: any;
+    originalDoc?: any;
+    data?: any;
+    user?: any;
+}) => any | Promise<any>;
+interface CollectionConfig {
+    slug: string;
+    labels?: {
+        singular: string;
+        plural: string;
+    };
+    auth?: boolean;
+    upload?: boolean | UploadConfig;
+    fields: Field[];
+    access?: {
+        read?: AccessFunction;
+        create?: AccessFunction;
+        update?: AccessFunction;
+        delete?: AccessFunction;
+    };
+    hooks?: {
+        beforeRead?: HookFunction[];
+        afterRead?: HookFunction[];
+        beforeChange?: HookFunction[];
+        afterChange?: HookFunction[];
+        beforeDelete?: HookFunction[];
+        afterDelete?: HookFunction[];
+    };
+    admin?: {
+        useAsTitle?: string;
+        defaultColumns?: string[];
+        group?: string;
+        hidden?: boolean;
+    };
+}
+interface UploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    imageSizes?: {
+        name: string;
+        width: number;
+        height: number;
+        crop?: string;
+    }[];
+}
+interface GlobalConfig {
+    slug: string;
+    label?: string;
+    fields: Field[];
+    access?: {
+        read?: AccessFunction;
+        update?: AccessFunction;
+    };
+    hooks?: {
+        beforeRead?: HookFunction[];
+        afterRead?: HookFunction[];
+        beforeChange?: HookFunction[];
+        afterChange?: HookFunction[];
+    };
+    admin?: {
+        group?: string;
+        hidden?: boolean;
+    };
+}
+interface PaginatedResult<T = any> {
+    docs: T[];
+    total: number;
+    limit: number;
+    page: number;
+}
+interface DatabaseAdapter {
+    find(args: {
+        collection: string;
+        where?: any;
+        limit?: number;
+        page?: number;
+        sort?: string;
+    }): Promise<PaginatedResult>;
+    findOne(args: {
+        collection: string;
+        id: string;
+    }): Promise<any>;
+    create(args: {
+        collection: string;
+        data: any;
+    }): Promise<any>;
+    update(args: {
+        collection: string;
+        id: string;
+        data: any;
+    }): Promise<any>;
+    delete(args: {
+        collection: string;
+        id: string;
+    }): Promise<any>;
+    getGlobal(args: {
+        slug: string;
+    }): Promise<any>;
+    updateGlobal(args: {
+        slug: string;
+        data: any;
+    }): Promise<any>;
+}
+interface FileData {
+    filename: string;
+    filesize?: number;
+    mimeType: string;
+    url: string;
+    width?: number;
+    height?: number;
+    type?: 'upload' | 'external';
+    provider?: string;
+    provider_metadata?: any;
+    [key: string]: any;
+}
+interface StorageAdapter {
+    upload(args: {
+        filename: string;
+        buffer: Buffer;
+        mimeType: string;
+    }): Promise<FileData>;
+    delete(args: {
+        filename: string;
+    }): Promise<void>;
+    getURL(args: {
+        filename: string;
+    }): string;
+}
+interface DyrectedConfig {
+    collections: CollectionConfig[];
+    globals: GlobalConfig[];
+    db: DatabaseAdapter;
+    storage?: StorageAdapter;
+    email?: {
+        provider: string;
+        apiKey?: string;
+        from: string;
+    };
+    redis?: {
+        url: string;
+    };
+    cors?: {
+        origins: string[];
+    };
+}
+
+interface DyrectedContext {
+    Variables: {
+        config: DyrectedConfig;
+        siteId?: string;
+    };
+}
+/**
+ * Create the main Dyrected Hono application.
+ */
+declare function createDyrectedApp(config: DyrectedConfig): Hono<DyrectedContext, hono_types.BlankSchema, "/">;
+
+declare class PopulationService {
+    private db;
+    private collections;
+    constructor(db: DatabaseAdapter, collections: CollectionConfig[]);
+    /**
+     * Recursively populate relationship fields in a document or array of documents.
+     */
+    populate(args: {
+        data: any;
+        fields: Field[];
+        currentDepth: number;
+        maxDepth: number;
+    }): Promise<any>;
+    /**
+     * Helper to populate a PaginatedResult
+     */
+    populateResult(result: PaginatedResult, fields: Field[], maxDepth: number): Promise<PaginatedResult>;
+}
+
+/**
+ * MediaService handles background tasks for media assets,
+ * such as extracting metadata from external URLs (YouTube/Vimeo).
+ */
+declare class MediaService {
+    /**
+     * Fetches metadata for a given URL.
+     * Supports YouTube and Vimeo.
+     */
+    static fetchMetadata(url: string): Promise<{
+        provider: string;
+        provider_id: string;
+        thumbnail: string;
+        embedUrl: string;
+        type: "video";
+    } | null>;
+    private static extractYoutubeId;
+    private static extractVimeoId;
+}
+
+/**
+ * Define a collection configuration with full type safety.
+ */
+declare function defineCollection(config: CollectionConfig): CollectionConfig;
+/**
+ * Define a global configuration with full type safety.
+ */
+declare function defineGlobal(config: GlobalConfig): GlobalConfig;
+/**
+ * Define the main Dyrected configuration.
+ */
+declare function defineConfig(config: DyrectedConfig): DyrectedConfig;
+
+export { type AccessFunction, type Block, type CollectionConfig, type DatabaseAdapter, type DyrectedConfig, type DyrectedContext, type Field, type FieldHook, type FieldType, type FileData, type GlobalConfig, type HookFunction, MediaService, type PaginatedResult, PopulationService, type StorageAdapter, type UploadConfig, createDyrectedApp, defineCollection, defineConfig, defineGlobal };

package/dist/index.js

@@ -0,0 +1,391 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MediaService: () => MediaService,
+  PopulationService: () => PopulationService,
+  createDyrectedApp: () => createDyrectedApp,
+  defineCollection: () => defineCollection,
+  defineConfig: () => defineConfig,
+  defineGlobal: () => defineGlobal
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/app.ts
+var import_hono = require("hono");
+var import_logger = require("hono/logger");
+var import_cors = require("hono/cors");
+var import_request_id = require("hono/request-id");
+
+// src/services/population.service.ts
+var PopulationService = class {
+  constructor(db, collections) {
+    this.db = db;
+    this.collections = collections;
+  }
+  db;
+  collections;
+  /**
+   * Recursively populate relationship fields in a document or array of documents.
+   */
+  async populate(args) {
+    const { data, fields, currentDepth, maxDepth } = args;
+    if (currentDepth >= maxDepth || !data) {
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return Promise.all(data.map((item) => this.populate({ ...args, data: item })));
+    }
+    const populatedDoc = { ...data };
+    for (const field of fields) {
+      const value = populatedDoc[field.name];
+      if (field.type === "relationship" && field.collection && value) {
+        const relatedCollection = this.collections.find((c) => c.slug === field.collection);
+        if (!relatedCollection) continue;
+        if (Array.isArray(value)) {
+          populatedDoc[field.name] = await Promise.all(
+            value.map(async (id) => {
+              const doc = await this.db.findOne({ collection: field.collection, id });
+              if (!doc) return id;
+              return this.populate({
+                data: doc,
+                fields: relatedCollection.fields,
+                currentDepth: currentDepth + 1,
+                maxDepth
+              });
+            })
+          );
+        } else if (typeof value === "string") {
+          const doc = await this.db.findOne({ collection: field.collection, id: value });
+          if (doc) {
+            populatedDoc[field.name] = await this.populate({
+              data: doc,
+              fields: relatedCollection.fields,
+              currentDepth: currentDepth + 1,
+              maxDepth
+            });
+          }
+        }
+      }
+      if ((field.type === "array" || field.type === "object") && field.fields && value) {
+        populatedDoc[field.name] = await this.populate({
+          data: value,
+          fields: field.fields,
+          currentDepth,
+          // Nested fields don't consume depth, only relationships do
+          maxDepth
+        });
+      }
+    }
+    return populatedDoc;
+  }
+  /**
+   * Helper to populate a PaginatedResult
+   */
+  async populateResult(result, fields, maxDepth) {
+    if (maxDepth <= 0) return result;
+    const populatedDocs = await this.populate({
+      data: result.docs,
+      fields,
+      currentDepth: 0,
+      maxDepth
+    });
+    return {
+      ...result,
+      docs: populatedDocs
+    };
+  }
+};
+
+// src/controllers/collection.controller.ts
+var CollectionController = class {
+  constructor(collection) {
+    this.collection = collection;
+  }
+  collection;
+  async find(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const limit = Number(c.req.query("limit")) || 10;
+    const page = Number(c.req.query("page")) || 1;
+    const depth = Number(c.req.query("depth")) || 0;
+    let result = await db.find({
+      collection: this.collection.slug,
+      limit,
+      page
+    });
+    if (depth > 0) {
+      const populationService = new PopulationService(db, config.collections);
+      result = await populationService.populateResult(result, this.collection.fields, depth);
+    }
+    return c.json(result);
+  }
+  async findOne(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const id = c.req.param("id");
+    const depth = Number(c.req.query("depth")) || 0;
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    const doc = await db.findOne({ collection: this.collection.slug, id });
+    if (!doc) return c.json({ message: "Not Found" }, 404);
+    if (depth > 0 && doc) {
+      const populationService = new PopulationService(db, config.collections);
+      const populatedDoc = await populationService.populate({
+        data: doc,
+        fields: this.collection.fields,
+        currentDepth: 0,
+        maxDepth: depth
+      });
+      return c.json(populatedDoc);
+    }
+    return c.json(doc);
+  }
+  async create(c) {
+    const db = c.get("config").db;
+    const body = await c.req.json();
+    const doc = await db.create({ collection: this.collection.slug, data: body });
+    return c.json(doc, 201);
+  }
+  async update(c) {
+    const db = c.get("config").db;
+    const id = c.req.param("id");
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    const body = await c.req.json();
+    const doc = await db.update({ collection: this.collection.slug, id, data: body });
+    return c.json(doc);
+  }
+  async delete(c) {
+    const db = c.get("config").db;
+    const id = c.req.param("id");
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    await db.delete({ collection: this.collection.slug, id });
+    return c.json({ message: "Deleted" });
+  }
+};
+
+// src/controllers/global.controller.ts
+var GlobalController = class {
+  constructor(global) {
+    this.global = global;
+  }
+  global;
+  async get(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const depth = Number(c.req.query("depth")) || 0;
+    const data = await db.getGlobal({ slug: this.global.slug });
+    if (depth > 0 && data) {
+      const populationService = new PopulationService(db, config.collections);
+      const populatedData = await populationService.populate({
+        data,
+        fields: this.global.fields,
+        currentDepth: 0,
+        maxDepth: depth
+      });
+      return c.json(populatedData);
+    }
+    return c.json(data || {});
+  }
+  async update(c) {
+    const db = c.get("config").db;
+    const body = await c.req.json();
+    const data = await db.updateGlobal({ slug: this.global.slug, data: body });
+    return c.json(data);
+  }
+};
+
+// src/controllers/media.controller.ts
+var MediaController = class {
+  async upload(c) {
+    const config = c.get("config");
+    const storage = config.storage;
+    if (!storage) {
+      return c.json({ message: "Storage not configured" }, 500);
+    }
+    const body = await c.req.parseBody();
+    const file = body["file"];
+    if (!file) {
+      return c.json({ message: "No file uploaded" }, 400);
+    }
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const fileData = await storage.upload({
+      filename: file.name,
+      buffer,
+      mimeType: file.type
+    });
+    const db = config.db;
+    const doc = await db.create({
+      collection: "media",
+      data: fileData
+    });
+    return c.json(doc, 201);
+  }
+  async find(c) {
+    const db = c.get("config").db;
+    const limit = Number(c.req.query("limit")) || 10;
+    const page = Number(c.req.query("page")) || 1;
+    const result = await db.find({
+      collection: "media",
+      limit,
+      page
+    });
+    return c.json(result);
+  }
+  async delete(c) {
+    const config = c.get("config");
+    const storage = config.storage;
+    const db = config.db;
+    const id = c.req.param("id");
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    const doc = await db.findOne({ collection: "media", id });
+    if (!doc) return c.json({ message: "Not Found" }, 404);
+    if (storage) {
+      await storage.delete({ filename: doc.filename });
+    }
+    await db.delete({ collection: "media", id });
+    return c.json({ message: "Deleted" });
+  }
+};
+
+// src/router.ts
+function registerRoutes(app, config) {
+  app.get("/api/schemas", (c) => {
+    return c.json({
+      collections: config.collections.map((col) => ({
+        slug: col.slug,
+        labels: col.labels,
+        fields: col.fields,
+        auth: col.auth,
+        upload: col.upload
+      })),
+      globals: config.globals.map((glb) => ({
+        slug: glb.slug,
+        label: glb.label,
+        fields: glb.fields
+      }))
+    });
+  });
+  if (config.storage) {
+    const mediaController = new MediaController();
+    app.get("/api/media", (c) => mediaController.find(c));
+    app.post("/api/media", (c) => mediaController.upload(c));
+    app.delete("/api/media/:id", (c) => mediaController.delete(c));
+  }
+  for (const collection of config.collections) {
+    const path = `/api/collections/${collection.slug}`;
+    const controller = new CollectionController(collection);
+    app.get(path, (c) => controller.find(c));
+    app.post(path, (c) => controller.create(c));
+    app.get(`${path}/:id`, (c) => controller.findOne(c));
+    app.patch(`${path}/:id`, (c) => controller.update(c));
+    app.delete(`${path}/:id`, (c) => controller.delete(c));
+  }
+  for (const global of config.globals) {
+    const path = `/api/globals/${global.slug}`;
+    const controller = new GlobalController(global);
+    app.get(path, (c) => controller.get(c));
+    app.patch(path, (c) => controller.update(c));
+  }
+}
+
+// src/app.ts
+function createDyrectedApp(config) {
+  const app = new import_hono.Hono();
+  app.use("*", (0, import_request_id.requestId)());
+  app.use("*", (0, import_logger.logger)());
+  app.use("*", (0, import_cors.cors)());
+  app.use("*", async (c, next) => {
+    c.set("config", config);
+    if (!c.get("siteId")) {
+      c.set("siteId", "default");
+    }
+    await next();
+  });
+  app.get("/health", (c) => c.json({ status: "ok", version: "0.0.1" }));
+  registerRoutes(app, config);
+  return app;
+}
+
+// src/services/media.service.ts
+var MediaService = class {
+  /**
+   * Fetches metadata for a given URL.
+   * Supports YouTube and Vimeo.
+   */
+  static async fetchMetadata(url) {
+    if (!url) return null;
+    if (url.includes("youtube.com") || url.includes("youtu.be")) {
+      const videoId = this.extractYoutubeId(url);
+      if (videoId) {
+        return {
+          provider: "youtube",
+          provider_id: videoId,
+          thumbnail: `https://img.youtube.com/vi/${videoId}/maxresdefault.jpg`,
+          embedUrl: `https://www.youtube.com/embed/${videoId}`,
+          type: "video"
+        };
+      }
+    }
+    if (url.includes("vimeo.com")) {
+      const vimeoId = this.extractVimeoId(url);
+      if (vimeoId) {
+        return {
+          provider: "vimeo",
+          provider_id: vimeoId,
+          thumbnail: "",
+          // Requires oEmbed API for reliable thumbnails
+          embedUrl: `https://player.vimeo.com/video/${vimeoId}`,
+          type: "video"
+        };
+      }
+    }
+    return null;
+  }
+  static extractYoutubeId(url) {
+    const regExp = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]*).*/;
+    const match = url.match(regExp);
+    return match && match[2].length === 11 ? match[2] : null;
+  }
+  static extractVimeoId(url) {
+    const match = url.match(/vimeo.com\/(?:channels\/(?:\w+\/)?|groups\/(?:[^\/]*)\/videos\/|album\/(?:\d+)\/video\/|video\/|)(\d+)(?:$|\/|\?)/);
+    return match ? match[1] : null;
+  }
+};
+
+// src/index.ts
+function defineCollection(config) {
+  return config;
+}
+function defineGlobal(config) {
+  return config;
+}
+function defineConfig(config) {
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MediaService,
+  PopulationService,
+  createDyrectedApp,
+  defineCollection,
+  defineConfig,
+  defineGlobal
+});

package/dist/index.mjs

@@ -0,0 +1,359 @@
+// src/app.ts
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { requestId } from "hono/request-id";
+
+// src/services/population.service.ts
+var PopulationService = class {
+  constructor(db, collections) {
+    this.db = db;
+    this.collections = collections;
+  }
+  db;
+  collections;
+  /**
+   * Recursively populate relationship fields in a document or array of documents.
+   */
+  async populate(args) {
+    const { data, fields, currentDepth, maxDepth } = args;
+    if (currentDepth >= maxDepth || !data) {
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return Promise.all(data.map((item) => this.populate({ ...args, data: item })));
+    }
+    const populatedDoc = { ...data };
+    for (const field of fields) {
+      const value = populatedDoc[field.name];
+      if (field.type === "relationship" && field.collection && value) {
+        const relatedCollection = this.collections.find((c) => c.slug === field.collection);
+        if (!relatedCollection) continue;
+        if (Array.isArray(value)) {
+          populatedDoc[field.name] = await Promise.all(
+            value.map(async (id) => {
+              const doc = await this.db.findOne({ collection: field.collection, id });
+              if (!doc) return id;
+              return this.populate({
+                data: doc,
+                fields: relatedCollection.fields,
+                currentDepth: currentDepth + 1,
+                maxDepth
+              });
+            })
+          );
+        } else if (typeof value === "string") {
+          const doc = await this.db.findOne({ collection: field.collection, id: value });
+          if (doc) {
+            populatedDoc[field.name] = await this.populate({
+              data: doc,
+              fields: relatedCollection.fields,
+              currentDepth: currentDepth + 1,
+              maxDepth
+            });
+          }
+        }
+      }
+      if ((field.type === "array" || field.type === "object") && field.fields && value) {
+        populatedDoc[field.name] = await this.populate({
+          data: value,
+          fields: field.fields,
+          currentDepth,
+          // Nested fields don't consume depth, only relationships do
+          maxDepth
+        });
+      }
+    }
+    return populatedDoc;
+  }
+  /**
+   * Helper to populate a PaginatedResult
+   */
+  async populateResult(result, fields, maxDepth) {
+    if (maxDepth <= 0) return result;
+    const populatedDocs = await this.populate({
+      data: result.docs,
+      fields,
+      currentDepth: 0,
+      maxDepth
+    });
+    return {
+      ...result,
+      docs: populatedDocs
+    };
+  }
+};
+
+// src/controllers/collection.controller.ts
+var CollectionController = class {
+  constructor(collection) {
+    this.collection = collection;
+  }
+  collection;
+  async find(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const limit = Number(c.req.query("limit")) || 10;
+    const page = Number(c.req.query("page")) || 1;
+    const depth = Number(c.req.query("depth")) || 0;
+    let result = await db.find({
+      collection: this.collection.slug,
+      limit,
+      page
+    });
+    if (depth > 0) {
+      const populationService = new PopulationService(db, config.collections);
+      result = await populationService.populateResult(result, this.collection.fields, depth);
+    }
+    return c.json(result);
+  }
+  async findOne(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const id = c.req.param("id");
+    const depth = Number(c.req.query("depth")) || 0;
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    const doc = await db.findOne({ collection: this.collection.slug, id });
+    if (!doc) return c.json({ message: "Not Found" }, 404);
+    if (depth > 0 && doc) {
+      const populationService = new PopulationService(db, config.collections);
+      const populatedDoc = await populationService.populate({
+        data: doc,
+        fields: this.collection.fields,
+        currentDepth: 0,
+        maxDepth: depth
+      });
+      return c.json(populatedDoc);
+    }
+    return c.json(doc);
+  }
+  async create(c) {
+    const db = c.get("config").db;
+    const body = await c.req.json();
+    const doc = await db.create({ collection: this.collection.slug, data: body });
+    return c.json(doc, 201);
+  }
+  async update(c) {
+    const db = c.get("config").db;
+    const id = c.req.param("id");
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    const body = await c.req.json();
+    const doc = await db.update({ collection: this.collection.slug, id, data: body });
+    return c.json(doc);
+  }
+  async delete(c) {
+    const db = c.get("config").db;
+    const id = c.req.param("id");
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    await db.delete({ collection: this.collection.slug, id });
+    return c.json({ message: "Deleted" });
+  }
+};
+
+// src/controllers/global.controller.ts
+var GlobalController = class {
+  constructor(global) {
+    this.global = global;
+  }
+  global;
+  async get(c) {
+    const config = c.get("config");
+    const db = config.db;
+    const depth = Number(c.req.query("depth")) || 0;
+    const data = await db.getGlobal({ slug: this.global.slug });
+    if (depth > 0 && data) {
+      const populationService = new PopulationService(db, config.collections);
+      const populatedData = await populationService.populate({
+        data,
+        fields: this.global.fields,
+        currentDepth: 0,
+        maxDepth: depth
+      });
+      return c.json(populatedData);
+    }
+    return c.json(data || {});
+  }
+  async update(c) {
+    const db = c.get("config").db;
+    const body = await c.req.json();
+    const data = await db.updateGlobal({ slug: this.global.slug, data: body });
+    return c.json(data);
+  }
+};
+
+// src/controllers/media.controller.ts
+var MediaController = class {
+  async upload(c) {
+    const config = c.get("config");
+    const storage = config.storage;
+    if (!storage) {
+      return c.json({ message: "Storage not configured" }, 500);
+    }
+    const body = await c.req.parseBody();
+    const file = body["file"];
+    if (!file) {
+      return c.json({ message: "No file uploaded" }, 400);
+    }
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const fileData = await storage.upload({
+      filename: file.name,
+      buffer,
+      mimeType: file.type
+    });
+    const db = config.db;
+    const doc = await db.create({
+      collection: "media",
+      data: fileData
+    });
+    return c.json(doc, 201);
+  }
+  async find(c) {
+    const db = c.get("config").db;
+    const limit = Number(c.req.query("limit")) || 10;
+    const page = Number(c.req.query("page")) || 1;
+    const result = await db.find({
+      collection: "media",
+      limit,
+      page
+    });
+    return c.json(result);
+  }
+  async delete(c) {
+    const config = c.get("config");
+    const storage = config.storage;
+    const db = config.db;
+    const id = c.req.param("id");
+    if (!id) return c.json({ message: "Missing ID" }, 400);
+    const doc = await db.findOne({ collection: "media", id });
+    if (!doc) return c.json({ message: "Not Found" }, 404);
+    if (storage) {
+      await storage.delete({ filename: doc.filename });
+    }
+    await db.delete({ collection: "media", id });
+    return c.json({ message: "Deleted" });
+  }
+};
+
+// src/router.ts
+function registerRoutes(app, config) {
+  app.get("/api/schemas", (c) => {
+    return c.json({
+      collections: config.collections.map((col) => ({
+        slug: col.slug,
+        labels: col.labels,
+        fields: col.fields,
+        auth: col.auth,
+        upload: col.upload
+      })),
+      globals: config.globals.map((glb) => ({
+        slug: glb.slug,
+        label: glb.label,
+        fields: glb.fields
+      }))
+    });
+  });
+  if (config.storage) {
+    const mediaController = new MediaController();
+    app.get("/api/media", (c) => mediaController.find(c));
+    app.post("/api/media", (c) => mediaController.upload(c));
+    app.delete("/api/media/:id", (c) => mediaController.delete(c));
+  }
+  for (const collection of config.collections) {
+    const path = `/api/collections/${collection.slug}`;
+    const controller = new CollectionController(collection);
+    app.get(path, (c) => controller.find(c));
+    app.post(path, (c) => controller.create(c));
+    app.get(`${path}/:id`, (c) => controller.findOne(c));
+    app.patch(`${path}/:id`, (c) => controller.update(c));
+    app.delete(`${path}/:id`, (c) => controller.delete(c));
+  }
+  for (const global of config.globals) {
+    const path = `/api/globals/${global.slug}`;
+    const controller = new GlobalController(global);
+    app.get(path, (c) => controller.get(c));
+    app.patch(path, (c) => controller.update(c));
+  }
+}
+
+// src/app.ts
+function createDyrectedApp(config) {
+  const app = new Hono();
+  app.use("*", requestId());
+  app.use("*", logger());
+  app.use("*", cors());
+  app.use("*", async (c, next) => {
+    c.set("config", config);
+    if (!c.get("siteId")) {
+      c.set("siteId", "default");
+    }
+    await next();
+  });
+  app.get("/health", (c) => c.json({ status: "ok", version: "0.0.1" }));
+  registerRoutes(app, config);
+  return app;
+}
+
+// src/services/media.service.ts
+var MediaService = class {
+  /**
+   * Fetches metadata for a given URL.
+   * Supports YouTube and Vimeo.
+   */
+  static async fetchMetadata(url) {
+    if (!url) return null;
+    if (url.includes("youtube.com") || url.includes("youtu.be")) {
+      const videoId = this.extractYoutubeId(url);
+      if (videoId) {
+        return {
+          provider: "youtube",
+          provider_id: videoId,
+          thumbnail: `https://img.youtube.com/vi/${videoId}/maxresdefault.jpg`,
+          embedUrl: `https://www.youtube.com/embed/${videoId}`,
+          type: "video"
+        };
+      }
+    }
+    if (url.includes("vimeo.com")) {
+      const vimeoId = this.extractVimeoId(url);
+      if (vimeoId) {
+        return {
+          provider: "vimeo",
+          provider_id: vimeoId,
+          thumbnail: "",
+          // Requires oEmbed API for reliable thumbnails
+          embedUrl: `https://player.vimeo.com/video/${vimeoId}`,
+          type: "video"
+        };
+      }
+    }
+    return null;
+  }
+  static extractYoutubeId(url) {
+    const regExp = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]*).*/;
+    const match = url.match(regExp);
+    return match && match[2].length === 11 ? match[2] : null;
+  }
+  static extractVimeoId(url) {
+    const match = url.match(/vimeo.com\/(?:channels\/(?:\w+\/)?|groups\/(?:[^\/]*)\/videos\/|album\/(?:\d+)\/video\/|video\/|)(\d+)(?:$|\/|\?)/);
+    return match ? match[1] : null;
+  }
+};
+
+// src/index.ts
+function defineCollection(config) {
+  return config;
+}
+function defineGlobal(config) {
+  return config;
+}
+function defineConfig(config) {
+  return config;
+}
+export {
+  MediaService,
+  PopulationService,
+  createDyrectedApp,
+  defineCollection,
+  defineConfig,
+  defineGlobal
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@dyrected/core",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "hono": "^4.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.12",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --watch --dts",
+    "lint": "eslint src/**/*.ts",
+    "test": "vitest"
+  }
+}