ai-database 0.0.0-development → 0.1.0

package/dist/index.js

@@ -0,0 +1,462 @@
+"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, {
+  DB: () => DB,
+  calculateSimilarity: () => calculateSimilarity,
+  createEdgeClient: () => createEdgeClient,
+  createNodeClient: () => createNodeClient,
+  db: () => db,
+  default: () => index_default,
+  generateEmbedding: () => generateEmbedding
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DB,
+  calculateSimilarity,
+  createEdgeClient,
+  createNodeClient,
+  db,
+  generateEmbedding
+});