ai-database 0.0.0-development → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,430 @@
+// src/utils.ts
+var handleError = (error, operation, collection) => {
+  const errorMessage = error.message || "Unknown error";
+  const statusCode = error.status || error.statusCode || 500;
+  const enhancedError = new Error(`${operation} operation failed on collection '${collection}': ${errorMessage}`);
+  Object.assign(enhancedError, {
+    statusCode,
+    operation,
+    collection,
+    originalError: error
+  });
+  throw enhancedError;
+};
+var transformQueryOptions = (options = {}) => {
+  const result = {};
+  if (options.where) {
+    result.where = options.where;
+  }
+  if (options.sort) {
+    if (Array.isArray(options.sort)) {
+      result.sort = options.sort.join(",");
+    } else {
+      result.sort = options.sort;
+    }
+  }
+  if (options.limit) {
+    result.limit = options.limit;
+  }
+  if (options.page) {
+    result.page = options.page;
+  }
+  if (options.select) {
+    if (Array.isArray(options.select)) {
+      result.fields = options.select;
+    } else {
+      result.fields = [options.select];
+    }
+  }
+  if (options.populate) {
+    if (typeof options.populate === "string") {
+      result.depth = 1;
+    } else if (Array.isArray(options.populate) && options.populate.length > 0) {
+      result.depth = 1;
+    }
+  }
+  return result;
+};
+var getPayloadInstance = (options) => {
+  if (options.payload) {
+    return options.payload;
+  }
+  if (options.apiUrl) {
+    const restConfig = {
+      apiUrl: options.apiUrl,
+      apiKey: options.apiKey,
+      headers: options.headers,
+      fetchOptions: options.fetchOptions
+    };
+    return createRestClient(restConfig);
+  }
+  try {
+    if (typeof global !== "undefined" && global.payload) {
+      return global.payload;
+    }
+  } catch (e) {
+  }
+  throw new Error("No Payload instance provided. Please provide a payload instance or apiUrl.");
+};
+var createRestClient = (config) => {
+  const { apiUrl, apiKey, headers = {}, fetchOptions = {} } = config;
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    ...headers
+  };
+  if (apiKey) {
+    requestHeaders["Authorization"] = `Bearer ${apiKey}`;
+  }
+  return {
+    find: async (options) => {
+      const { collection, ...params } = options;
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (typeof value === "object") {
+          searchParams.append(key, JSON.stringify(value));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      });
+      const url = `${apiUrl}/${collection}?${searchParams.toString()}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: requestHeaders,
+        ...fetchOptions
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || `Failed to fetch from ${collection}`);
+      }
+      return response.json();
+    },
+    findByID: async (options) => {
+      const { collection, id, ...params } = options;
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (typeof value === "object") {
+          searchParams.append(key, JSON.stringify(value));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      });
+      const url = `${apiUrl}/${collection}/${id}?${searchParams.toString()}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: requestHeaders,
+        ...fetchOptions
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || `Failed to fetch ${id} from ${collection}`);
+      }
+      return response.json();
+    },
+    create: async (options) => {
+      const { collection, data } = options;
+      const url = `${apiUrl}/${collection}`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: requestHeaders,
+        body: JSON.stringify(data),
+        ...fetchOptions
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || `Failed to create document in ${collection}`);
+      }
+      return response.json();
+    },
+    update: async (options) => {
+      const { collection, id, data } = options;
+      const url = `${apiUrl}/${collection}/${id}`;
+      const response = await fetch(url, {
+        method: "PATCH",
+        headers: requestHeaders,
+        body: JSON.stringify(data),
+        ...fetchOptions
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || `Failed to update document ${id} in ${collection}`);
+      }
+      return response.json();
+    },
+    delete: async (options) => {
+      const { collection, id } = options;
+      const url = `${apiUrl}/${collection}/${id}`;
+      const response = await fetch(url, {
+        method: "DELETE",
+        headers: requestHeaders,
+        ...fetchOptions
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || `Failed to delete document ${id} from ${collection}`);
+      }
+      return response.json();
+    }
+  };
+};
+
+// src/collectionHandler.ts
+var CollectionHandler = class {
+  payload;
+  collection;
+  /**
+   * Creates a new collection handler
+   * @param options Collection handler options
+   */
+  constructor(options) {
+    this.payload = options.payload;
+    this.collection = options.collectionName;
+  }
+  /**
+   * Find documents in the collection
+   * @template T Type of documents to return
+   * @param options Query options including filtering, sorting, and pagination
+   * @returns Promise resolving to a list of documents
+   */
+  async find(options = {}) {
+    try {
+      const transformedOptions = transformQueryOptions(options);
+      const result = await this.payload.find({
+        collection: this.collection,
+        ...transformedOptions
+      });
+      return {
+        docs: result.docs || [],
+        totalDocs: result.totalDocs || 0,
+        page: result.page || 1,
+        totalPages: result.totalPages || 1,
+        limit: result.limit || 10,
+        hasPrevPage: result.hasPrevPage || false,
+        hasNextPage: result.hasNextPage || false,
+        prevPage: result.prevPage || null,
+        nextPage: result.nextPage || null
+      };
+    } catch (error) {
+      return handleError(error, "find", this.collection);
+    }
+  }
+  /**
+   * Find a single document by ID
+   * @template T Type of document to return
+   * @param id Document ID
+   * @returns Promise resolving to a single document
+   */
+  async findOne(id) {
+    try {
+      return await this.payload.findByID({
+        collection: this.collection,
+        id
+      });
+    } catch (error) {
+      return handleError(error, "findOne", this.collection);
+    }
+  }
+  /**
+   * Create a new document in the collection
+   * @template T Type of document to create
+   * @param data Document data
+   * @returns Promise resolving to the created document
+   */
+  async create(data) {
+    try {
+      return await this.payload.create({
+        collection: this.collection,
+        data
+      });
+    } catch (error) {
+      return handleError(error, "create", this.collection);
+    }
+  }
+  /**
+   * Update an existing document
+   * @template T Type of document to update
+   * @param id Document ID
+   * @param data Updated document data
+   * @returns Promise resolving to the updated document
+   */
+  async update(id, data) {
+    try {
+      return await this.payload.update({
+        collection: this.collection,
+        id,
+        data
+      });
+    } catch (error) {
+      return handleError(error, "update", this.collection);
+    }
+  }
+  /**
+   * Delete a document
+   * @template T Type of deleted document
+   * @param id Document ID
+   * @returns Promise resolving to the deleted document
+   */
+  async delete(id) {
+    try {
+      return await this.payload.delete({
+        collection: this.collection,
+        id
+      });
+    } catch (error) {
+      return handleError(error, "delete", this.collection);
+    }
+  }
+  /**
+   * Search for documents
+   * @template T Type of documents to search
+   * @param query Search query string
+   * @param options Query options
+   * @returns Promise resolving to a list of matching documents
+   */
+  async search(query, options = {}) {
+    try {
+      const transformedOptions = transformQueryOptions(options);
+      if (typeof this.payload.search === "function") {
+        const result2 = await this.payload.search({
+          collection: this.collection,
+          query,
+          ...transformedOptions
+        });
+        return {
+          docs: result2.docs || [],
+          totalDocs: result2.totalDocs || 0,
+          page: result2.page || 1,
+          totalPages: result2.totalPages || 1,
+          limit: result2.limit || 10,
+          hasPrevPage: result2.hasPrevPage || false,
+          hasNextPage: result2.hasNextPage || false,
+          prevPage: result2.prevPage || null,
+          nextPage: result2.nextPage || null
+        };
+      }
+      const result = await this.payload.find({
+        collection: this.collection,
+        search: query,
+        ...transformedOptions
+      });
+      return {
+        docs: result.docs || [],
+        totalDocs: result.totalDocs || 0,
+        page: result.page || 1,
+        totalPages: result.totalPages || 1,
+        limit: result.limit || 10,
+        hasPrevPage: result.hasPrevPage || false,
+        hasNextPage: result.hasNextPage || false,
+        prevPage: result.prevPage || null,
+        nextPage: result.nextPage || null
+      };
+    } catch (error) {
+      return handleError(error, "search", this.collection);
+    }
+  }
+};
+
+// src/adapters/node.ts
+var createNodeClient = (options = {}) => {
+  return DB(options);
+};
+
+// src/adapters/edge.ts
+var createEdgeClient = (options = {}) => {
+  if (!options.apiUrl) {
+    throw new Error("apiUrl is required for Edge environments");
+  }
+  return DB(options);
+};
+
+// src/embedding.ts
+async function generateEmbedding(text, options = {}) {
+  try {
+    const modelName = options.model || "text-embedding-3-small";
+    const apiKey = options.apiKey || typeof globalThis !== "undefined" && globalThis.process?.env?.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("apiKey option or OPENAI_API_KEY environment variable is required for embedding generation");
+    }
+    const input = Array.isArray(text) ? text : [text];
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        input,
+        model: modelName
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`OpenAI API error: ${errorData.error?.message || response.statusText}`);
+    }
+    const data = await response.json();
+    const embeddings = [];
+    if (data && data.data && Array.isArray(data.data)) {
+      for (const item of data.data) {
+        if (item && item.embedding && Array.isArray(item.embedding)) {
+          embeddings.push(item.embedding);
+        }
+      }
+    }
+    return {
+      embedding: embeddings.length > 0 ? embeddings : null,
+      model: modelName,
+      success: embeddings.length > 0
+    };
+  } catch (error) {
+    console.error("Error generating embedding:", error);
+    return {
+      embedding: null,
+      model: options.model || "text-embedding-3-small",
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function calculateSimilarity(embedding1, embedding2) {
+  if (embedding1.length !== embedding2.length) {
+    throw new Error("Embeddings must have the same dimensions");
+  }
+  let dotProduct = 0;
+  let magnitude1 = 0;
+  let magnitude2 = 0;
+  for (let i = 0; i < embedding1.length; i++) {
+    dotProduct += embedding1[i] * embedding2[i];
+    magnitude1 += embedding1[i] * embedding1[i];
+    magnitude2 += embedding2[i] * embedding2[i];
+  }
+  magnitude1 = Math.sqrt(magnitude1);
+  magnitude2 = Math.sqrt(magnitude2);
+  if (magnitude1 === 0 || magnitude2 === 0) {
+    return 0;
+  }
+  return dotProduct / (magnitude1 * magnitude2);
+}
+
+// src/index.ts
+var DB = (options = {}) => {
+  const payload = getPayloadInstance(options);
+  return new Proxy({}, {
+    get: (target, prop) => {
+      if (typeof prop === "string" && prop !== "then") {
+        const collectionName = prop === "resources" ? "things" : String(prop);
+        return new CollectionHandler({ payload, collectionName });
+      }
+      return target[prop];
+    }
+  });
+};
+var db = DB();
+var index_default = DB;
+export {
+  DB,
+  calculateSimilarity,
+  createEdgeClient,
+  createNodeClient,
+  db,
+  index_default as default,
+  generateEmbedding
+};

package/package.json

@@ -1,33 +1,47 @@
 {
   "name": "ai-database",
-  "version": "0.0.0-development",
-  "description": "AI-native database abstraction with hybrid vector search for synthetic data and RAG applications. Currently using local mdxdb types until @mdxdb/types is published.",
-  "type": "module",
+  "version": "0.1.0",
+  "description": "Direct interface to Payload CMS with database.do compatibility",
   "main": "dist/index.js",
-  "types": "dist/types/index.d.ts",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "files": [
-    "dist/types"
+    "dist",
+    "README.md"
   ],
   "scripts": {
-    "build": "tsc",
-    "test": "vitest",
-    "lint": "eslint .",
-    "format": "prettier --write ."
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup --watch",
+    "lint": "eslint src",
+    "format": "prettier --write src",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "payload",
+    "cms",
+    "database",
+    "api"
+  ],
+  "author": "Drivly",
+  "license": "MIT",
+  "homepage": "https://mdx.org.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/drivly/ai"
+  },
+  "bugs": {
+    "url": "https://github.com/drivly/ai/issues"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.0.0",
-    "eslint-config-prettier": "^9.0.0",
-    "mdxld": "^0.1.0",
-    "prettier": "^3.0.0",
+    "apis.do": "0.1.0",
+    "payload": "^2.0.0",
+    "tsup": "^8.0.0",
     "typescript": "^5.0.0",
     "vitest": "^1.0.0"
   },
-  "dependencies": {
-    "@ai-sdk/openai": "^1.0.8",
-    "ai": "^2.2.37",
-    "openai": "^4.76.3"
+  "engines": {
+    "node": ">=18"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 AI Primitives
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/types/database.d.ts

@@ -1,46 +0,0 @@
-import { AIDocument } from './document';
-import { AIVectorSearchOptions } from './vector';
-/**
- * Configuration options for the AI-native database
- */
-export interface DatabaseConfig {
-    /**
-     * Database name or identifier
-     */
-    name: string;
-    /**
-     * Optional vector search configuration
-     */
-    vectorSearch?: {
-        /**
-         * Dimensions for vector embeddings
-         */
-        dimensions?: number;
-        /**
-         * Model to use for embeddings
-         */
-        model?: string;
-    };
-    /**
-     * Optional synthetic data generation configuration
-     */
-    synthetic?: {
-        /**
-         * Model to use for synthetic data generation
-         */
-        model?: string;
-    };
-}
-/**
- * Database provider interface
- */
-export interface DatabaseProvider {
-    /**
-     * Query documents using AI-powered vector search
-     */
-    query(options: AIVectorSearchOptions): Promise<AIDocument[]>;
-    /**
-     * Insert a document into the database
-     */
-    insert(document: AIDocument): Promise<void>;
-}

package/dist/types/document.d.ts

@@ -1,15 +0,0 @@
-import type { Document } from './mdxdb/types';
-export interface AIDocument extends Document {
-    metadata?: {
-        model?: string;
-        temperature?: number;
-        tokens?: number;
-        provider?: string;
-    };
-    synthetic?: boolean;
-    toolCalls?: Array<{
-        name: string;
-        arguments: Record<string, unknown>;
-        result?: unknown;
-    }>;
-}

package/dist/types/index.d.ts

@@ -1,5 +0,0 @@
-export * from './document';
-export * from './vector';
-export * from './tools';
-export * from './synthetic';
-export * from './database';

package/dist/types/mdxdb/embedding.d.ts

@@ -1,7 +0,0 @@
-export interface EmbeddingOptions {
-    dimensions?: number;
-    model?: string;
-}
-export interface EmbeddingProvider {
-    embed(text: string, options?: EmbeddingOptions): Promise<number[]>;
-}

package/dist/types/mdxdb/types.d.ts

@@ -1,59 +0,0 @@
-import type { MDXLD } from 'mdxld';
-export interface Document extends MDXLD {
-    embeddings?: number[];
-    collections?: string[];
-}
-export interface VectorSearchOptions {
-    vector?: number[];
-    query?: string;
-    filter?: Record<string, unknown>;
-    k?: number;
-    threshold?: number;
-}
-export interface NamespaceOptions {
-    defaultNamespace?: string;
-    enforceHttps?: boolean;
-    maxPathDepth?: number;
-    allowSubdomains?: boolean;
-}
-export interface DatabaseOptions {
-    namespace: string;
-    baseUrl?: string;
-    options?: NamespaceOptions;
-}
-export interface CollectionOptions {
-    path: string;
-    database: DatabaseProvider;
-}
-export interface DatabaseProvider<T extends Document = Document> {
-    namespace: string;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    list(): Promise<string[]>;
-    collection(name: string): CollectionProvider<T>;
-    [key: string]: DatabaseProvider<T> | CollectionProvider<T> | string | (() => Promise<void>) | (() => Promise<string[]>) | ((name: string) => CollectionProvider<T>);
-}
-export type FilterQuery<T> = {
-    [K in keyof T]?: T[K] | {
-        $eq?: T[K];
-        $gt?: T[K];
-        $gte?: T[K];
-        $lt?: T[K];
-        $lte?: T[K];
-        $in?: T[K][];
-        $nin?: T[K][];
-    };
-};
-export interface SearchOptions<T extends Document = Document> {
-    filter?: FilterQuery<T>;
-    threshold?: number;
-    limit?: number;
-    offset?: number;
-    includeVectors?: boolean;
-}
-export interface CollectionProvider<T extends Document = Document> {
-    path: string;
-    find(filter: FilterQuery<T>, options?: SearchOptions<T>): Promise<T[]>;
-    search(query: string, options?: SearchOptions<T>): Promise<T[]>;
-    vectorSearch(options: VectorSearchOptions & SearchOptions<T>): Promise<T[]>;
-}

package/dist/types/synthetic.d.ts

@@ -1,9 +0,0 @@
-export interface SyntheticDataOptions {
-    schema: Record<string, unknown>;
-    count: number;
-    model?: string;
-    temperature?: number;
-}
-export interface SyntheticDataProvider {
-    generate(options: SyntheticDataOptions): Promise<unknown[]>;
-}

package/dist/types/tools.d.ts

@@ -1,10 +0,0 @@
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-    returns: Record<string, unknown>;
-}
-export interface ToolProvider {
-    namespace: string;
-    tools: ToolDefinition[];
-}

package/dist/types/vector.d.ts

@@ -1,16 +0,0 @@
-import type { VectorSearchOptions } from './mdxdb/types';
-import type { EmbeddingOptions, EmbeddingProvider } from './mdxdb/embedding';
-export interface AIVectorSearchOptions extends VectorSearchOptions {
-    rerank?: boolean;
-    hybridWeight?: number;
-    contextWindow?: number;
-}
-export interface AIEmbeddingOptions extends EmbeddingOptions {
-    provider?: string;
-    batchSize?: number;
-    normalize?: boolean;
-}
-export interface AIEmbeddingProvider extends EmbeddingProvider {
-    batchEmbed?(texts: string[], options?: AIEmbeddingOptions): Promise<number[][]>;
-    normalize?(vector: number[]): number[];
-}