opacacms 0.1.12 → 0.1.13

package/src/client.ts

@@ -1,181 +0,0 @@
-import type { OpacaConfig } from "./types";
-
-export interface OpacaClientOptions {
-  baseURL: string;
-  token?: string;
-}
-
-/**
- * A proxy-based client that provides a typed experience for interacting with the OpacaCMS API.
- */
-export interface GeneratedTypes {
-  collections: Record<string, any>;
-  globals: Record<string, any>;
-}
-
-/**
- * Custom error class for OpacaCMS SDK errors.
- */
-export class OpacaError extends Error {
-  status: number;
-  data: any;
-
-  constructor(message: string, status: number, data: any = {}) {
-    super(message);
-    this.name = "OpacaError";
-    this.status = status;
-    this.data = data;
-  }
-}
-
-export function createClient<T = any>(configOrOptions: T | OpacaClientOptions) {
-  const options: OpacaClientOptions = (configOrOptions as any).serverURL
-    ? { baseURL: (configOrOptions as any).serverURL }
-    : (configOrOptions as OpacaClientOptions);
-
-  const baseURL = options.baseURL.replace(/\/$/, "");
-
-  const getHeaders = () => {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-    };
-    if (options.token) {
-      headers.Authorization = `Bearer ${options.token}`;
-    }
-    return headers;
-  };
-
-  const fetcher = async (path: string, init?: RequestInit) => {
-    const res = await fetch(`${baseURL}${path}`, {
-      ...init,
-      credentials: "include", // Required for session cookies in cross-origin environments
-      headers: {
-        ...getHeaders(),
-        ...init?.headers,
-      },
-    });
-
-    if (!res.ok) {
-      const errorData: any = await res.json().catch(() => ({}));
-      throw new OpacaError(errorData.message || `API Error: ${res.status}`, res.status, errorData);
-    }
-
-    return res.json();
-  };
-
-  const client = {
-    getMetadata: () => fetcher("/api/__admin/metadata"),
-    getCollections: () => fetcher("/api/__admin/collections"),
-    getSetupStatus: () => fetcher("/api/__admin/setup"),
-
-    // Legacy mapping (collections and globals)
-    collections: new Proxy({} as any, {
-      get(_, collectionSlug) {
-        return {
-          find: (query?: any) => {
-            const searchParams = new URLSearchParams();
-            if (query) {
-              Object.entries(query).forEach(([key, value]) => {
-                searchParams.append(
-                  key,
-                  typeof value === "object" ? JSON.stringify(value) : String(value),
-                );
-              });
-            }
-            const queryString = searchParams.toString();
-            return fetcher(`/api/${String(collectionSlug)}${queryString ? `?${queryString}` : ""}`);
-          },
-          findOne: (id: string) => fetcher(`/api/${String(collectionSlug)}/${id}`),
-          list: () => fetcher(`/api/${String(collectionSlug)}`),
-          create: (data: any) =>
-            fetcher(`/api/${String(collectionSlug)}`, {
-              method: "POST",
-              body: JSON.stringify(data),
-            }),
-          update: (id: string, data: any) =>
-            fetcher(`/api/${String(collectionSlug)}/${id}`, {
-              method: "PATCH",
-              body: JSON.stringify(data),
-            }),
-          delete: (id: string) =>
-            fetcher(`/api/${String(collectionSlug)}/${id}`, {
-              method: "DELETE",
-            }),
-        };
-      },
-    }),
-
-    globals: new Proxy({} as any, {
-      get(_, globalSlug) {
-        return {
-          get: () => fetcher(`/api/globals/${String(globalSlug)}`),
-          update: (data: any) =>
-            fetcher(`/api/globals/${String(globalSlug)}`, {
-              method: "PATCH",
-              body: JSON.stringify(data),
-            }),
-        };
-      },
-    }),
-  };
-
-  // Infer types based on whether T is an OpacaConfig or GeneratedTypes interface
-  type TCollections = T extends OpacaConfig
-    ? T["collections"] extends any[]
-    ? T["collections"][number]["slug"]
-    : string
-    : T extends GeneratedTypes
-    ? keyof T["collections"]
-    : string;
-
-  type TGlobals = T extends OpacaConfig
-    ? T["globals"] extends any[]
-    ? T["globals"][number]["slug"]
-    : string
-    : T extends GeneratedTypes
-    ? keyof T["globals"]
-    : string;
-
-  type GetCollectionItem<K> = T extends GeneratedTypes
-    ? K extends keyof T["collections"]
-    ? T["collections"][K]
-    : any
-    : any;
-  type GetGlobalItem<K> = T extends GeneratedTypes
-    ? K extends keyof T["globals"]
-    ? T["globals"][K]
-    : any
-    : any;
-
-  return client as any as {
-    getMetadata: () => Promise<any>;
-    getCollections: () => Promise<any[]>;
-    getSetupStatus: () => Promise<{ initialized: boolean }>;
-    collections: {
-      [K in TCollections]: {
-        find: (query?: any) => Promise<{
-          docs: GetCollectionItem<K>[];
-          totalDocs: number;
-          page: number;
-          totalPages: number;
-        }>;
-        findOne: (id: string) => Promise<GetCollectionItem<K>>;
-        list: () => Promise<{
-          docs: GetCollectionItem<K>[];
-          totalDocs: number;
-          page: number;
-          totalPages: number;
-        }>;
-        create: (data: Partial<GetCollectionItem<K>>) => Promise<GetCollectionItem<K>>;
-        update: (id: string, data: Partial<GetCollectionItem<K>>) => Promise<GetCollectionItem<K>>;
-        delete: (id: string) => Promise<{ success: boolean }>;
-      };
-    };
-    globals: {
-      [K in TGlobals]: {
-        get: () => Promise<GetGlobalItem<K>>;
-        update: (data: Partial<GetGlobalItem<K>>) => Promise<GetGlobalItem<K>>;
-      };
-    };
-  };
-}

package/src/config-utils.ts

@@ -1,102 +0,0 @@
-import { getSystemCollections } from "./db/system-schema";
-import type { Field, OpacaConfig, SerializableCollection, SerializableConfig } from "./types";
-
-/**
- * Sanitizes the OpacaConfig to ensure it's safe to pass to Client Components or over the API.
- * Strips out functions (hooks, access) and the database adapter.
- */
-export function sanitizeConfig(config: OpacaConfig): SerializableConfig {
-  const collections = [...config.collections];
-
-  // Auto-inject system collections (auth + assets) if relevant features are enabled
-  const supportsAuth =
-    config.db.name === "sqlite" || config.db.name === "postgres" || config.db.name === "d1";
-
-  const systemCollections = getSystemCollections();
-
-  for (const systemCol of systemCollections) {
-    const isAsset = systemCol.slug === "_opaca_assets";
-    const isAuth = ["_users", "_sessions", "_accounts", "_verifications", "_api_keys"].includes(
-      systemCol.slug,
-    );
-
-    if ((isAsset && config.storages) || (isAuth && supportsAuth)) {
-      if (!collections.find((col) => col.slug === systemCol.slug)) {
-        collections.push({
-          ...systemCol,
-          admin: true,
-        } as any);
-      }
-    }
-  }
-
-  const sanitizeField = (f: Field): SerializableCollection["fields"][number] => ({
-    name: f.name,
-    type: f.type,
-    label: f.label,
-    required: f.required,
-    unique: f.unique,
-    defaultValue: (f as any).defaultValue,
-    localized: f.localized,
-    admin: f.admin
-      ? {
-        description: f.admin.description,
-        hidden: f.admin.hidden,
-        readOnly: f.admin.readOnly,
-        components: f.admin.components,
-      }
-      : undefined,
-    options: (f as any).options,
-    fields: (f as any).fields ? (f as any).fields.map(sanitizeField) : undefined,
-    relationTo: (f as any).relationTo,
-    displayField: (f as any).displayField,
-    collection: (f as any).collection,
-    on: (f as any).on,
-    blocks: (f as any).blocks
-      ? (f as any).blocks.map((b: any) => ({
-        slug: b.slug,
-        label: b.label,
-        fields: b.fields.map(sanitizeField),
-      }))
-      : undefined,
-    tabs: (f as any).tabs
-      ? (f as any).tabs.map((t: any) => ({
-        label: t.label,
-        fields: t.fields.map(sanitizeField),
-      }))
-      : undefined,
-  });
-
-  return {
-    appName: config.appName,
-    serverURL: config.serverURL,
-    collections: collections.map((col) => ({
-      slug: col.slug,
-      apiPath: col.apiPath,
-      label: col.label,
-      icon: col.icon,
-      admin: col.admin,
-      hidden: col.hidden,
-      fields: col.fields.map(sanitizeField),
-      timestamps: col.timestamps,
-      auth: col.auth,
-      versions: col.versions,
-    })),
-    globals: config.globals?.map((g) => ({
-      slug: g.slug,
-      label: g.label,
-      icon: g.icon,
-      fields: g.fields.map(sanitizeField),
-    })),
-    storages: config.storages
-      ? Object.keys(config.storages).reduce(
-        (acc, key) => {
-          (acc as Record<string, unknown>)[key] = {};
-          return acc;
-        },
-        {} as Record<string, unknown>,
-      )
-      : {},
-    i18n: config.i18n,
-  };
-}

package/src/config.ts

@@ -1,49 +0,0 @@
-/**
- * Helper to define the OpacaCMS configuration with full type safety.
- */
-import type { Collection, OpacaConfig } from "./types";
-import { OpacaConfigSchema } from "./validation";
-
-/**
- * Recursively builds any object that has a .build() method.
- * This is used to normalize Fluent API builders into plain objects.
- */
-function recursivelyBuild(obj: any): any {
-  if (!obj || typeof obj !== "object") return obj;
-
-  // If it has a build method, it's one of our builders
-  if (typeof obj.build === "function") {
-    return recursivelyBuild(obj.build());
-  }
-
-  // If it's an array, build its elements
-  if (Array.isArray(obj)) {
-    return obj.map(recursivelyBuild);
-  }
-
-  // If it's not a plain object (e.g., an instance of a DatabaseAdapter), return as is
-  if (obj.constructor !== Object) {
-    return obj;
-  }
-
-  // It's a plain object, build its properties
-  const built: any = {};
-  for (const [key, value] of Object.entries(obj)) {
-    built[key] = recursivelyBuild(value);
-  }
-  return built;
-}
-
-/**
- * Helper logic to infer slugs from collections.
- */
-export function defineConfig<const TCollections extends readonly Collection[]>(
-  config: OpacaConfig<TCollections[number]["slug"]> & { collections: TCollections },
-): OpacaConfig<TCollections[number]["slug"]> {
-  const builtConfig = recursivelyBuild(config);
-  const result = OpacaConfigSchema.safeParse(builtConfig);
-  if (!result.success) {
-    throw new Error(`Invalid OpacaCMS Configuration: ${result.error.message}`);
-  }
-  return builtConfig;
-}

package/src/db/adapter.ts

@@ -1,53 +0,0 @@
-import type { Collection, DatabaseAdapter, FindOptions, Global, PaginatedResult } from "../types";
-
-/**
- * BaseDatabaseAdapter is an abstract class that implements the DatabaseAdapter interface.
- * It provides a foundation for database adapters and enforces the implementation of required methods.
- */
-export abstract class BaseDatabaseAdapter implements DatabaseAdapter {
-  abstract name: string;
-  public get raw(): unknown {
-    return undefined;
-  }
-  public get db(): unknown {
-    return undefined;
-  }
-  abstract connect(): Promise<void>;
-  abstract disconnect(): Promise<void>;
-
-  /**
-   * Execute a raw SQL query directly on the database.
-   */
-  abstract unsafe(sql: string, params?: any[]): Promise<any>;
-
-  /**
-   * Count documents in a collection.
-   */
-  abstract count(collection: string, query?: any): Promise<number>;
-
-  abstract create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
-  abstract find<T extends object>(
-    collection: string,
-    query?: any,
-    options?: FindOptions,
-  ): Promise<PaginatedResult<T>>;
-  abstract findOne<T extends object>(collection: string, query: any): Promise<T | null>;
-  abstract update<T extends object>(collection: string, query: any, data: Partial<T>): Promise<T>;
-  abstract updateMany?<T extends object>(
-    collection: string,
-    query: any,
-    data: Partial<T>,
-  ): Promise<number>;
-  abstract delete(collection: string, query: any): Promise<boolean>;
-  abstract deleteMany?(collection: string, query: any): Promise<number>;
-
-  abstract findGlobal?<T extends object>(slug: string): Promise<T | null>;
-  abstract updateGlobal?<T extends object>(slug: string, data: Partial<T>): Promise<T>;
-
-  abstract migrate(collections: Collection[], globals?: Global[]): Promise<void>;
-
-  public push?: boolean;
-  public pushDestructive?: boolean;
-  public migrationDir?: string;
-  public runMigrations?(): Promise<void>;
-}