opacacms 0.1.0 → 0.1.2

package/dist/src/storage/index.js

@@ -1,355 +0,0 @@
-import {
-  __require
-} from "../../chunk-8sqjbsgt.js";
-
-// src/storage/errors.ts
-class StorageError extends Error {
-  provider;
-  operation;
-  originalError;
-  constructor(provider, operation, message, originalError) {
-    const originalMessage = originalError instanceof Error ? `: ${originalError.message}` : originalError ? `: ${String(originalError)}` : "";
-    super(`[OpacaStorage::${provider}] Failed to ${operation}: ${message}${originalMessage}`);
-    this.name = "StorageError";
-    this.provider = provider;
-    this.operation = operation;
-    this.originalError = originalError;
-  }
-}
-
-class FileTooLargeError extends StorageError {
-  constructor(provider, maxBytes, actualBytes) {
-    super(provider, "upload", `File size (${actualBytes} bytes) exceeds the maximum allowed (${maxBytes} bytes).`);
-    this.name = "FileTooLargeError";
-  }
-}
-
-class Invalidmime_typeError extends StorageError {
-  constructor(provider, allowedTypes, actualType) {
-    super(provider, "upload", `MIME type '${actualType}' is not allowed. Expected one of: ${allowedTypes.join(", ")}.`);
-    this.name = "Invalidmime_typeError";
-  }
-}
-
-// src/storage/adapters/cloudflare-r2.ts
-function createR2Storage(config) {
-  const getFullKey = (filename) => {
-    return config.prefix ? `${config.prefix.replace(/\/$/, "")}/${filename}` : filename;
-  };
-  const getPublicUrl = (filename) => {
-    if (!config.publicUrl) {
-      throw new Error("Cloudflare R2 requires a 'publicUrl' (custom domain) configured in the adapter to return accessible URLs.");
-    }
-    return `${config.publicUrl.replace(/\/$/, "")}/${getFullKey(filename)}`;
-  };
-  return {
-    name: "cloudflare-r2",
-    async upload(file, options) {
-      try {
-        if (options?.allowedmime_types && !options.allowedmime_types.includes(file.mime_type)) {
-          throw new Invalidmime_typeError("cloudflare-r2", options.allowedmime_types, file.mime_type);
-        }
-        if (options?.maxFileSize && file.filesize > options.maxFileSize) {
-          throw new FileTooLargeError("cloudflare-r2", options.maxFileSize, file.filesize);
-        }
-        let finalFilename = file.filename;
-        if (options?.generateUniqueName) {
-          const ext = file.original_filename.split(".").pop() || "";
-          const hash = crypto.randomUUID().split("-")[0];
-          finalFilename = `${finalFilename.replace(`.${ext}`, "")}-${hash}.${ext}`;
-        }
-        const key = getFullKey(finalFilename);
-        const body = file.buffer || file.stream;
-        if (!body) {
-          throw new StorageError("cloudflare-r2", "upload", `No content provided for file ${file.filename}`);
-        }
-        await config.bucketBinding.put(key, body, {
-          httpMetadata: {
-            contentType: file.mime_type
-          }
-        });
-        return {
-          filename: finalFilename,
-          mime_type: file.mime_type,
-          filesize: file.filesize,
-          url: getPublicUrl(finalFilename)
-        };
-      } catch (error) {
-        if (error instanceof StorageError)
-          throw error;
-        throw new StorageError("cloudflare-r2", "upload", `Failed to upload ${file.filename} to R2 bucket`, error);
-      }
-    },
-    async delete(filename) {
-      try {
-        await config.bucketBinding.delete(getFullKey(filename));
-      } catch (error) {
-        throw new StorageError("cloudflare-r2", "delete", `Failed to delete ${filename} from R2 bucket`, error);
-      }
-    },
-    async exists(filename) {
-      try {
-        const head = await config.bucketBinding.head(getFullKey(filename));
-        return head !== null;
-      } catch (error) {
-        throw new StorageError("cloudflare-r2", "exists", `Failed to check existence of ${filename} in R2 bucket`, error);
-      }
-    },
-    async download(filename) {
-      try {
-        const object = await config.bucketBinding.get(getFullKey(filename));
-        if (!object) {
-          throw new StorageError("cloudflare-r2", "download", `File not found: ${filename}`);
-        }
-        return object.body;
-      } catch (error) {
-        if (error instanceof StorageError)
-          throw error;
-        throw new StorageError("cloudflare-r2", "download", `Failed to download ${filename} from R2 bucket`, error);
-      }
-    }
-  };
-}
-// src/storage/adapters/local.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-function createLocalAdapter(config) {
-  fs.mkdir(config.uploadDir, { recursive: true }).catch((err) => {
-    console.error(`[OpacaCMS:LocalAdapter] Failed to create upload directory ${config.uploadDir}:`, err);
-  });
-  const getFullPath = (filename) => {
-    return path.join(config.uploadDir, filename);
-  };
-  const getPublicUrl = (filename) => {
-    const base = config.publicUrl.replace(/\/$/, "");
-    return `${base}/${filename}`;
-  };
-  return {
-    name: "local",
-    async upload(file, options) {
-      try {
-        if (options?.allowedmime_types && !options.allowedmime_types.includes(file.mime_type)) {
-          throw new Invalidmime_typeError("local", options.allowedmime_types, file.mime_type);
-        }
-        if (options?.maxFileSize && file.filesize > options.maxFileSize) {
-          throw new FileTooLargeError("local", options.maxFileSize, file.filesize);
-        }
-        let finalFilename = file.filename;
-        if (options?.generateUniqueName) {
-          const ext = path.extname(file.original_filename);
-          const hash = crypto.randomUUID().split("-")[0];
-          const base = path.basename(finalFilename, ext).replace(/[^a-z0-9]/gi, "-").toLowerCase();
-          finalFilename = `${base}-${hash}${ext}`;
-        }
-        const sanitizedFilename = path.basename(finalFilename);
-        const fullPath = path.resolve(config.uploadDir, sanitizedFilename);
-        if (!fullPath.startsWith(path.resolve(config.uploadDir))) {
-          throw new StorageError("local", "upload", "Path traversal attempt detected.");
-        }
-        if (file.buffer && typeof Bun !== "undefined") {
-          await Bun.write(fullPath, file.buffer);
-        } else if (file.buffer) {
-          await fs.writeFile(fullPath, file.buffer);
-        } else if (file.stream) {
-          const writeStream = __require("node:fs").createWriteStream(fullPath);
-          const reader = file.stream.getReader();
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              if (value) {
-                writeStream.write(Buffer.from(value));
-              }
-            }
-          } finally {
-            writeStream.end();
-            reader.releaseLock();
-          }
-        } else {
-          throw new Error("Neither Buffer nor Stream provided.");
-        }
-        return {
-          filename: sanitizedFilename,
-          mime_type: file.mime_type,
-          filesize: file.filesize,
-          url: getPublicUrl(sanitizedFilename)
-        };
-      } catch (error) {
-        if (error instanceof StorageError)
-          throw error;
-        throw new StorageError("local", "upload", `Failed to write ${file.filename} to disk`, error);
-      }
-    },
-    async delete(filename) {
-      try {
-        const fullPath = getFullPath(path.basename(filename));
-        await fs.unlink(fullPath);
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          throw new StorageError("local", "delete", `Failed to delete ${filename}`, error);
-        }
-      }
-    },
-    async exists(filename) {
-      try {
-        await fs.access(getFullPath(path.basename(filename)), __require("node:fs").constants.F_OK);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    async download(filename) {
-      const fullPath = getFullPath(path.basename(filename));
-      if (typeof Bun !== "undefined") {
-        return Bun.file(fullPath).stream();
-      }
-      const nodeStream = __require("node:fs").createReadStream(fullPath);
-      return new ReadableStream({
-        start(controller) {
-          nodeStream.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
-          nodeStream.on("end", () => controller.close());
-          nodeStream.on("error", (err) => controller.error(err));
-        },
-        cancel() {
-          nodeStream.destroy();
-        }
-      });
-    }
-  };
-}
-// src/storage/adapters/s3.ts
-import {
-  DeleteObjectCommand,
-  GetObjectCommand,
-  HeadObjectCommand,
-  PutObjectCommand,
-  S3Client
-} from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-function createS3Adapter(config) {
-  const s3Client = new S3Client({
-    region: config.region,
-    endpoint: config.endpoint,
-    credentials: config.credentials,
-    forcePathStyle: config.forcePathStyle
-  });
-  const getFullKey = (filename) => {
-    if (config.prefix) {
-      const p = config.prefix.replace(/\/$/, "");
-      return `${p}/${filename}`;
-    }
-    return filename;
-  };
-  const getPublicUrl = (filename) => {
-    if (config.publicUrl) {
-      const base = config.publicUrl.replace(/\/$/, "");
-      return `${base}/${getFullKey(filename)}`;
-    }
-    return `https://${config.bucket}.s3.${config.region}.amazonaws.com/${getFullKey(filename)}`;
-  };
-  return {
-    name: "s3",
-    async upload(file, options) {
-      try {
-        if (options?.allowedmime_types && !options.allowedmime_types.includes(file.mime_type)) {
-          throw new Invalidmime_typeError("s3", options.allowedmime_types, file.mime_type);
-        }
-        if (options?.maxFileSize && file.filesize > options.maxFileSize) {
-          throw new FileTooLargeError("s3", options.maxFileSize, file.filesize);
-        }
-        let finalFilename = file.filename;
-        if (options?.generateUniqueName) {
-          const ext = file.original_filename.split(".").pop() || "";
-          const hash = crypto.randomUUID().split("-")[0];
-          const base = finalFilename.replace(`.${ext}`, "").replace(/[^a-z0-9]/gi, "-").toLowerCase();
-          finalFilename = `${base}-${hash}.${ext}`;
-        }
-        const key = getFullKey(finalFilename);
-        const body = file.buffer || file.stream;
-        const command = new PutObjectCommand({
-          Bucket: config.bucket,
-          Key: key,
-          Body: body,
-          ContentType: file.mime_type,
-          ContentLength: file.filesize,
-          ACL: config.acl || "private"
-        });
-        await s3Client.send(command);
-        return {
-          filename: finalFilename,
-          mime_type: file.mime_type,
-          filesize: file.filesize,
-          url: getPublicUrl(finalFilename)
-        };
-      } catch (error) {
-        if (error instanceof StorageError)
-          throw error;
-        throw new StorageError("s3", "upload", `Failed to upload ${file.filename} to S3 bucket ${config.bucket}`, error);
-      }
-    },
-    async delete(filename) {
-      try {
-        const command = new DeleteObjectCommand({
-          Bucket: config.bucket,
-          Key: getFullKey(filename)
-        });
-        await s3Client.send(command);
-      } catch (error) {
-        throw new StorageError("s3", "delete", `Failed to delete ${filename} from S3 bucket ${config.bucket}`, error);
-      }
-    },
-    async exists(filename) {
-      try {
-        const command = new HeadObjectCommand({
-          Bucket: config.bucket,
-          Key: getFullKey(filename)
-        });
-        await s3Client.send(command);
-        return true;
-      } catch (error) {
-        if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404)
-          return false;
-        throw new StorageError("s3", "download", `Failed to check existence of ${filename}`, error);
-      }
-    },
-    async generatePresignedUrl(filename, operation, expiresInSeconds = 3600) {
-      try {
-        let command;
-        if (operation === "write") {
-          command = new PutObjectCommand({ Bucket: config.bucket, Key: getFullKey(filename) });
-        } else {
-          command = new GetObjectCommand({ Bucket: config.bucket, Key: getFullKey(filename) });
-        }
-        return await getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
-      } catch (error) {
-        throw new StorageError("s3", "presign", `Failed to generate presigned URL for ${filename}`, error);
-      }
-    },
-    async download(filename) {
-      try {
-        const command = new GetObjectCommand({
-          Bucket: config.bucket,
-          Key: getFullKey(filename)
-        });
-        const response = await s3Client.send(command);
-        if (!response.Body) {
-          throw new StorageError("s3", "download", `File not found: ${filename}`);
-        }
-        return response.Body.transformToWebStream();
-      } catch (error) {
-        if (error instanceof StorageError)
-          throw error;
-        throw new StorageError("s3", "download", `Failed to download ${filename} from S3 bucket ${config.bucket}`, error);
-      }
-    }
-  };
-}
-export {
-  createS3Adapter,
-  createR2Storage,
-  createLocalAdapter,
-  StorageError,
-  Invalidmime_typeError,
-  FileTooLargeError
-};

package/global.d.ts

@@ -1,11 +0,0 @@
-import "hono";
-import type { OpacaConfig, User } from "./src/types";
-import type { Auth } from "./src/auth/index";
-
-declare module "hono" {
-  interface ContextVariableMap {
-    config: OpacaConfig;
-    auth: Auth;
-    user: User;
-  }
-}

package/src/admin/api-client.ts

@@ -1,63 +0,0 @@
-import ky from "ky";
-
-let client: typeof ky | null = null;
-let currentBaseURL: string | null = null;
-
-export const configureAPI = (serverUrl: string) => {
-  if (!serverUrl || !serverUrl.startsWith("http")) return;
-  const url = serverUrl;
-  const baseURL = url.replace(/\/$/, "");
-  if (client && currentBaseURL === baseURL) return;
-
-  currentBaseURL = baseURL;
-  client = ky.create({
-    prefixUrl: baseURL,
-    credentials: "include",
-    retry: 0,
-    hooks: {
-      afterResponse: [
-        async (_request, _options, response) => {
-          if (response.status === 401 || response.status === 403) {
-            // Se o auth handler do backend falhar globalmente em qualquer requisição da API (sessão morreu/expirada)
-            // Lançamos a revalidação da store local para despachar o usuário pra tela de login.
-            try {
-              const { $session } = await import("./stores/auth");
-              const { notify } = await import("./stores/ui");
-              $session.set(null);
-              notify("Session expired. Please log in again.", "error");
-            } catch (e) {}
-          }
-        },
-      ],
-    },
-  });
-};
-
-export const getCurrentBaseURL = () => {
-  if (!currentBaseURL) {
-    throw new Error("API client not configured. Did you provide a valid serverUrl?");
-  }
-  return currentBaseURL as string;
-};
-
-/**
- * A proxy for ky that allows us to configure the baseURL late
- * (e.g. after we have the serverURL from props).
- * @param prop: string
- */
-export const api = new Proxy({} as typeof ky, {
-  get(_, prop) {
-    if (!client) {
-      // No auto-fallback for web components.
-      throw new Error("API client not configured. Did you provide a valid serverUrl?");
-    }
-
-    if (!client) throw new Error("API client not configured");
-
-    const c = client;
-    if (c) {
-      return c[prop as keyof typeof ky];
-    }
-    return undefined;
-  },
-});

package/src/admin/auth-client.ts

@@ -1,40 +0,0 @@
-import { createAuthClient } from "better-auth/client";
-import { adminClient } from "better-auth/client/plugins";
-import { logger } from "@/utils/logger";
-
-let client: ReturnType<typeof createAuthClient> | null = null;
-let currentURL: string | null = null;
-
-export const configureAuth = (serverUrl: string) => {
-  if (!serverUrl || !serverUrl.startsWith("http")) return;
-  const url = serverUrl;
-  const baseURL = url.replace(/\/$/, "") + "/api/auth";
-  if (client && currentURL === baseURL) return;
-
-  currentURL = baseURL;
-  client = createAuthClient({
-    baseURL,
-    autoRefresh: true,
-    fetchOptions: {
-      credentials: "include",
-    },
-    plugins: [adminClient()],
-  });
-};
-
-/**
- * A proxy for the authClient that allows us to configure it late
- * (e.g. after we have the user's config with serverURL).
- */
-export const authClient = new Proxy({} as ReturnType<typeof createAuthClient>, {
-  get(_, prop) {
-    if (!client) {
-      // No auto-fallback to origin for web components.
-      // AdminClient will call configureAuth when it has the correct prop.
-      throw new Error("Auth client not configured. Did you provide a valid serverUrl?");
-    }
-    return (client as ReturnType<typeof createAuthClient>)[
-      prop as keyof ReturnType<typeof createAuthClient>
-    ];
-  },
-});

package/src/admin/custom-field.ts

@@ -1,179 +0,0 @@
-export interface CustomFieldProps<TValue = any, TConfig = Record<string, any>> {
-  /** The current value of the field from the CMS database */
-  value: TValue;
-  /** The full schema configuration of the field */
-  fieldConfig: TConfig;
-  /** Whether the field is currently disabled by access control */
-  disabled: boolean;
-  /** Whether the field is currently read-only by access control */
-  readOnly: boolean;
-  /** A validation error message from the CMS, if any */
-  error?: string;
-  /** The current full state of the parent form or row */
-  parentData?: Record<string, unknown>;
-  /** Callback to notify the CMS that the data has changed */
-  onChange: (value: TValue) => void;
-}
-
-export interface CustomFieldAdapter {
-  /**
-   * Called exactly once when the field is inserted into the CMS Admin UI.
-   * Use this to render your React root, Vue app, or Vanilla DOM nodes.
-   *
-   * @param container The DOM element acting as the wrapper for your component.
-   * @param props The initial properties (value, config, onChange) from the CMS.
-   */
-  mount: (container: HTMLElement, props: CustomFieldProps) => void;
-
-  /**
-   * Called whenever the CMS pushes new data to the field (e.g. form resets,
-   * external value changes).
-   *
-   * @param container The same DOM element wrapper.
-   * @param props The updated properties.
-   */
-  update?: (container: HTMLElement, props: CustomFieldProps) => void;
-
-  /**
-   * Called exactly once when the field is removed from the DOM (e.g., navigating away).
-   * Use this to unmount your React root or Vue app to prevent memory leaks.
-   *
-   * @param container The same DOM element wrapper.
-   */
-  unmount?: (container: HTMLElement) => void;
-}
-
-/**
- * A built-in utility to register framework-agnostic Custom Web Components for the OpacaCMS Admin UI.
- *
- * It acts as an adapter, translating the Web Component lifecycle (`connectedCallback`, `disconnectedCallback`,
- * property setters) into a simple `mount` / `update` / `unmount` paradigm that can easily wrap React, Vue, Angular,
- * or plain Javascript applications.
- *
- * @example
- * ```tsx
- * import { defineCustomField } from 'opacacms/admin';
- * import { createRoot } from 'react-dom/client';
- *
- * defineCustomField('my-react-picker', {
- *   mount: (container, props) => {
- *     (container as any)._root = createRoot(container);
- *     (container as any)._root.render(<MyPicker {...props} />);
- *   },
- *   update: (container, props) => {
- *     (container as any)._root.render(<MyPicker {...props} />);
- *   },
- *   unmount: (container) => {
- *     (container as any)._root.unmount();
- *   }
- * });
- * ```
- *
- * @param tagName The tag name to register in the browser (e.g., `opaca-color-picker`). Must contain a hyphen.
- * @param adapter The adapter containing `mount`, optional `update`, and optional `unmount` lifecycle methods.
- */
-export function defineCustomField(tagName: string, adapter: CustomFieldAdapter) {
-  if (typeof window === "undefined") return;
-
-  if (customElements.get(tagName)) {
-    console.warn(`[OpacaCMS] Custom field tag "${tagName}" is already defined.`);
-    return;
-  }
-
-  class OpacaCustomFieldElement extends HTMLElement {
-    private _value: any;
-    private _fieldConfig: any;
-    private _error?: string;
-    private _parentData?: Record<string, unknown>;
-    private _isMounted = false;
-
-    // Helper to abstract the complex CustomEvent away from the user's DX
-    private handleChange = (newValue: any) => {
-      this.dispatchEvent(
-        new CustomEvent("opacachange", {
-          detail: { value: newValue },
-          bubbles: true,
-          composed: true,
-        }),
-      );
-    };
-
-    private getProps(): CustomFieldProps {
-      return {
-        value: this._value,
-        fieldConfig: this._fieldConfig,
-        disabled: this.getAttribute("data-disabled") === "true",
-        readOnly: this.getAttribute("data-readonly") === "true",
-        error: this._error,
-        parentData: this._parentData,
-        onChange: this.handleChange,
-      };
-    }
-
-    set error(err: string | undefined) {
-      if (this._error !== err) {
-        this._error = err;
-        if (this._isMounted && adapter.update) {
-          adapter.update(this, this.getProps());
-        }
-      }
-    }
-
-    get error() {
-      return this._error;
-    }
-
-    set parentData(data: Record<string, unknown> | undefined) {
-      this._parentData = data;
-      if (this._isMounted && adapter.update) {
-        adapter.update(this, this.getProps());
-      }
-    }
-
-    get parentData() {
-      return this._parentData;
-    }
-
-    set value(val: any) {
-      const oldValue = this._value;
-      this._value = val;
-      // Only call update if the value actually changed and the component is mounted
-      if (this._isMounted && adapter.update && oldValue !== val) {
-        adapter.update(this, this.getProps());
-      }
-    }
-
-    get value() {
-      return this._value;
-    }
-
-    set fieldConfig(config: any) {
-      this._fieldConfig = config;
-      if (this._isMounted && adapter.update) {
-        adapter.update(this, this.getProps());
-      }
-    }
-
-    get fieldConfig() {
-      return this._fieldConfig;
-    }
-
-    connectedCallback() {
-      if (!this._isMounted) {
-        adapter.mount(this, this.getProps());
-        this._isMounted = true;
-      }
-    }
-
-    disconnectedCallback() {
-      if (this._isMounted) {
-        if (adapter.unmount) {
-          adapter.unmount(this);
-        }
-        this._isMounted = false;
-      }
-    }
-  }
-
-  customElements.define(tagName, OpacaCustomFieldElement);
-}

package/src/admin/index.ts

@@ -1,15 +0,0 @@
-export {
-  type CustomFieldAdapter,
-  type CustomFieldProps,
-  defineCustomField,
-} from "./custom-field";
-export { defineReactField } from "./react";
-export * from "./router";
-export * from "./stores/config";
-export * from "./stores/query";
-export * from "./stores/ui";
-export { AdminClient } from "./ui/admin-client";
-export { AdminLayout } from "./ui/admin-layout";
-export { Breadcrumbs } from "./ui/components/ui/breadcrumbs";
-export { Link } from "./ui/components/link";
-export { Toast, ToastContainer } from "./ui/components/toast";