@deessejs/collections 0.0.51 → 0.2.0

package/dist/index.js

@@ -1,24 +1,870 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+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, desc2) => {
+  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: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  array: () => array,
+  boolean: () => boolean,
+  buildSchema: () => buildSchema,
+  buildTable: () => buildTable,
+  collection: () => collection,
+  createCollectionOperations: () => createCollectionOperations,
+  date: () => date,
+  defineConfig: () => defineConfig,
+  email: () => email,
+  f: () => f,
+  field: () => field,
+  fieldType: () => fieldType,
+  generate: () => generate,
+  json: () => json,
+  migrate: () => migrate,
+  number: () => number,
+  pgAdapter: () => pgAdapter,
+  push: () => push,
+  relation: () => relation,
+  select: () => select,
+  text: () => text,
+  timestamp: () => timestamp,
+  url: () => url
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/field-type.ts
+var fieldType = (config) => {
+  return () => ({
+    schema: config.schema,
+    database: config.database ?? {}
+  });
+};
+
+// src/field.ts
+var field = (config) => {
+  return {
+    fieldType: config.fieldType,
+    required: config.required ?? false,
+    unique: config.unique ?? false,
+    indexed: config.indexed ?? false,
+    default: config.default,
+    label: config.label,
+    description: config.description
+  };
+};
+
+// src/fields/f.ts
+var import_zod = require("zod");
+var getItemType = (itemSchema) => {
+  if (itemSchema instanceof import_zod.z.ZodString) return "text";
+  if (itemSchema instanceof import_zod.z.ZodNumber) return "integer";
+  if (itemSchema instanceof import_zod.z.ZodBoolean) return "boolean";
+  if (itemSchema instanceof import_zod.z.ZodDate) return "timestamp";
+  if (itemSchema instanceof import_zod.z.ZodEnum) return "text";
+  if (itemSchema instanceof import_zod.z.ZodArray) return "array";
+  if (itemSchema instanceof import_zod.z.ZodObject) return "jsonb";
+  return "text";
+};
+var f = {
+  /**
+   * Text field type
+   */
+  text: () => fieldType({
+    schema: import_zod.z.string(),
+    database: { type: "text" }
+  })(),
+  /**
+   * Email field type with built-in validation
+   */
+  email: () => fieldType({
+    schema: import_zod.z.string().email(),
+    database: { type: "text" }
+  })(),
+  /**
+   * URL field type with built-in validation
+   */
+  url: () => fieldType({
+    schema: import_zod.z.string().url(),
+    database: { type: "text" }
+  })(),
+  /**
+   * Number field type
+   */
+  number: () => fieldType({
+    schema: import_zod.z.number(),
+    database: { type: "integer" }
+  })(),
+  /**
+   * Boolean field type
+   */
+  boolean: () => fieldType({
+    schema: import_zod.z.boolean(),
+    database: { type: "boolean" }
+  })(),
+  /**
+   * Date field type (date only, no time)
+   */
+  date: () => fieldType({
+    schema: import_zod.z.date(),
+    database: { type: "date" }
+  })(),
+  /**
+   * Timestamp field type (date with time)
+   */
+  timestamp: () => fieldType({
+    schema: import_zod.z.date(),
+    database: { type: "timestamp" }
+  })(),
+  /**
+   * Creates a select field type
+   */
+  select: (options) => fieldType({
+    schema: import_zod.z.enum(options),
+    database: { type: "text" }
+  })(),
+  /**
+   * JSON field type for storing JSON data
+   */
+  json: (schema) => fieldType({
+    schema: schema ?? import_zod.z.any(),
+    database: { type: "jsonb" }
+  })(),
+  /**
+   * Array field type for storing lists
+   */
+  array: (itemSchema) => fieldType({
+    schema: import_zod.z.array(itemSchema),
+    database: { type: "array", itemType: getItemType(itemSchema) }
+  })(),
+  /**
+   * Creates a relation field type for foreign key relationships
+   */
+  relation: (options) => {
+    const isMany = options.many ?? false;
+    const isSingular = options.singular ?? false;
+    return fieldType({
+      schema: isMany ? import_zod.z.array(import_zod.z.string()) : import_zod.z.string(),
+      database: {
+        type: "integer",
+        references: options.collection,
+        through: options.through,
+        many: isMany,
+        singular: isSingular
+      }
+    })();
+  }
+};
+var text = f.text;
+var email = f.email;
+var url = f.url;
+var number = f.number;
+var boolean = f.boolean;
+var date = f.date;
+var timestamp = f.timestamp;
+var select = f.select;
+var json = f.json;
+var array = f.array;
+var relation = f.relation;
+
+// src/collection.ts
+var collection = (config) => {
+  return {
+    slug: config.slug,
+    name: config.name,
+    fields: config.fields,
+    hooks: config.hooks,
+    dataType: config.dataType
+  };
+};
+
+// src/operations/collection-operations.ts
+var import_drizzle_orm = require("drizzle-orm");
+var buildWhereClause = (tableColumns, where) => {
+  if (!where) return void 0;
+  const conditions = [];
+  for (const [key, value] of Object.entries(where)) {
+    const column = tableColumns[key];
+    if (!column) continue;
+    if (value === null || typeof value !== "object") {
+      conditions.push((0, import_drizzle_orm.eq)(column, value));
+    } else {
+      const operator = value;
+      if ("eq" in operator) {
+        conditions.push((0, import_drizzle_orm.eq)(column, operator.eq));
+      } else if ("neq" in operator) {
+        conditions.push((0, import_drizzle_orm.not)((0, import_drizzle_orm.eq)(column, operator.neq)));
+      } else if ("gt" in operator) {
+        conditions.push((0, import_drizzle_orm.gt)(column, operator.gt));
+      } else if ("gte" in operator) {
+        conditions.push((0, import_drizzle_orm.gte)(column, operator.gte));
+      } else if ("lt" in operator) {
+        conditions.push((0, import_drizzle_orm.lt)(column, operator.lt));
+      } else if ("lte" in operator) {
+        conditions.push((0, import_drizzle_orm.lte)(column, operator.lte));
+      } else if ("in" in operator) {
+        conditions.push((0, import_drizzle_orm.inArray)(column, operator.in));
+      } else if ("notIn" in operator) {
+        conditions.push((0, import_drizzle_orm.not)((0, import_drizzle_orm.inArray)(column, operator.notIn)));
+      } else if ("contains" in operator) {
+        conditions.push((0, import_drizzle_orm.like)(column, `%${operator.contains}%`));
+      } else if ("startsWith" in operator) {
+        conditions.push((0, import_drizzle_orm.like)(column, `${operator.startsWith}%`));
+      } else if ("endsWith" in operator) {
+        conditions.push((0, import_drizzle_orm.like)(column, `%${operator.endsWith}`));
+      } else if ("isNull" in operator) {
+        if (operator.isNull) {
+          conditions.push((0, import_drizzle_orm.isNull)(column));
+        }
+      } else if ("not" in operator) {
+        conditions.push((0, import_drizzle_orm.not)((0, import_drizzle_orm.eq)(column, operator.not)));
+      }
+    }
+  }
+  if (conditions.length === 0) return void 0;
+  if (conditions.length === 1) return conditions[0];
+  return (0, import_drizzle_orm.and)(...conditions);
+};
+var buildOrderBy = (tableColumns, orderBy) => {
+  if (!orderBy) return [];
+  const orders = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return orders.map((order) => {
+    for (const [key, direction] of Object.entries(order)) {
+      const column = tableColumns[key];
+      if (!column) continue;
+      return direction === "desc" ? (0, import_drizzle_orm.desc)(column) : (0, import_drizzle_orm.asc)(column);
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./collections"), exports);
-__exportStar(require("./config"), exports);
-__exportStar(require("./drizzle"), exports);
-__exportStar(require("./dsl"), exports);
-__exportStar(require("./fields"), exports);
-__exportStar(require("./next"), exports);
-__exportStar(require("./plugins"), exports);
-__exportStar(require("./providers"), exports);
+    return void 0;
+  }).filter(Boolean);
+};
+var executeBeforeOperationHooks = async (hooks, context) => {
+  if (!hooks?.beforeOperation) return;
+  for (const hook of hooks.beforeOperation) {
+    await hook(context);
+  }
+};
+var executeAfterOperationHooks = async (hooks, context) => {
+  if (!hooks?.afterOperation) return;
+  for (const hook of hooks.afterOperation) {
+    await hook(context);
+  }
+};
+var executeBeforeCreateHooks = async (hooks, context) => {
+  if (!hooks?.beforeCreate) return;
+  for (const hook of hooks.beforeCreate) {
+    await hook(context);
+  }
+};
+var executeAfterCreateHooks = async (hooks, context) => {
+  if (!hooks?.afterCreate) return;
+  for (const hook of hooks.afterCreate) {
+    await hook(context);
+  }
+};
+var executeBeforeUpdateHooks = async (hooks, context) => {
+  if (!hooks?.beforeUpdate) return;
+  for (const hook of hooks.beforeUpdate) {
+    await hook(context);
+  }
+};
+var executeAfterUpdateHooks = async (hooks, context) => {
+  if (!hooks?.afterUpdate) return;
+  for (const hook of hooks.afterUpdate) {
+    await hook(context);
+  }
+};
+var executeBeforeDeleteHooks = async (hooks, context) => {
+  if (!hooks?.beforeDelete) return;
+  for (const hook of hooks.beforeDelete) {
+    await hook(context);
+  }
+};
+var executeAfterDeleteHooks = async (hooks, context) => {
+  if (!hooks?.afterDelete) return;
+  for (const hook of hooks.afterDelete) {
+    await hook(context);
+  }
+};
+var executeBeforeReadHooks = async (hooks, context) => {
+  if (!hooks?.beforeRead) return;
+  for (const hook of hooks.beforeRead) {
+    await hook(context);
+  }
+};
+var executeAfterReadHooks = async (hooks, context) => {
+  if (!hooks?.afterRead) return;
+  for (const hook of hooks.afterRead) {
+    await hook(context);
+  }
+};
+var createCollectionOperations = (_collection, _slug, _db, _table, _hooks) => {
+  const tableColumns = _table;
+  const db = _db;
+  const hooks = _hooks;
+  if (!db) {
+    return {
+      findMany: async () => [],
+      findUnique: async () => void 0,
+      findFirst: async () => void 0,
+      create: async () => void 0,
+      createMany: async () => 0,
+      update: async () => void 0,
+      updateMany: async () => 0,
+      delete: async () => void 0,
+      deleteMany: async () => 0,
+      count: async () => 0,
+      exists: async () => false
+    };
+  }
+  return {
+    findMany: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options?.where);
+      const orderByClause = buildOrderBy(tableColumns, options?.orderBy);
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options?.where
+      });
+      await executeBeforeReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        db
+      });
+      let query = db.select().from(_table);
+      if (whereClause) {
+        query = query.where(whereClause);
+      }
+      if (orderByClause.length > 0) {
+        query = query.orderBy(...orderByClause);
+      }
+      if (options?.offset) {
+        query = query.offset(options.offset);
+      }
+      if (options?.limit) {
+        query = query.limit(options.limit);
+      }
+      const result = await query;
+      await executeAfterReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        result,
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options?.where,
+        result
+      });
+      return result;
+    },
+    findUnique: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      if (!whereClause) return void 0;
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options.where
+      });
+      await executeBeforeReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        db
+      });
+      const result = await db.select().from(_table).where(whereClause).limit(1);
+      const returnValue = result[0];
+      await executeAfterReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        result: returnValue ? [returnValue] : [],
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options.where,
+        result: returnValue
+      });
+      return returnValue;
+    },
+    findFirst: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      const orderByClause = buildOrderBy(tableColumns, options.orderBy);
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options.where
+      });
+      await executeBeforeReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        db
+      });
+      let query = db.select().from(_table);
+      if (whereClause) {
+        query = query.where(whereClause);
+      }
+      if (orderByClause.length > 0) {
+        query = query.orderBy(...orderByClause);
+      }
+      const result = await query.limit(1);
+      const returnValue = result[0];
+      await executeAfterReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        result: returnValue ? [returnValue] : [],
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options.where,
+        result: returnValue
+      });
+      return returnValue;
+    },
+    create: async (options) => {
+      const data = Array.isArray(options.data) ? options.data : [options.data];
+      const firstData = data[0];
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "create",
+        data: firstData,
+        where: void 0
+      });
+      await executeBeforeCreateHooks(hooks, {
+        collection: _slug,
+        operation: "create",
+        data: firstData,
+        db
+      });
+      const result = await db.insert(_table).values(data).returning();
+      const returnValue = options.returning ? result[0] : void 0;
+      await executeAfterCreateHooks(hooks, {
+        collection: _slug,
+        operation: "create",
+        data: firstData,
+        result: returnValue,
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "create",
+        data: firstData,
+        result: returnValue
+      });
+      return returnValue;
+    },
+    createMany: async (options) => {
+      const dataArray = Array.isArray(options.data) ? options.data : [options.data];
+      for (const data of dataArray) {
+        await executeBeforeOperationHooks(hooks, {
+          collection: _slug,
+          operation: "create",
+          data,
+          where: void 0
+        });
+        await executeBeforeCreateHooks(hooks, {
+          collection: _slug,
+          operation: "create",
+          data,
+          db
+        });
+      }
+      const result = await db.insert(_table).values(options.data);
+      for (let i = 0; i < dataArray.length; i++) {
+        await executeAfterCreateHooks(hooks, {
+          collection: _slug,
+          operation: "create",
+          data: dataArray[i],
+          result: result[i],
+          db
+        });
+        await executeAfterOperationHooks(hooks, {
+          collection: _slug,
+          operation: "create",
+          data: dataArray[i],
+          result: result[i]
+        });
+      }
+      return result.length || 0;
+    },
+    update: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      if (!whereClause) return void 0;
+      const previousResult = await db.select().from(_table).where(whereClause).limit(1);
+      const previousData = previousResult[0];
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "update",
+        data: options.data,
+        where: options.where
+      });
+      await executeBeforeUpdateHooks(hooks, {
+        collection: _slug,
+        operation: "update",
+        data: options.data,
+        where: options.where,
+        previousData,
+        db
+      });
+      const result = await db.update(_table).set(options.data).where(whereClause).returning();
+      const returnValue = options.returning ? result[0] : void 0;
+      await executeAfterUpdateHooks(hooks, {
+        collection: _slug,
+        operation: "update",
+        data: options.data,
+        where: options.where,
+        previousData,
+        result: returnValue,
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "update",
+        data: options.data,
+        where: options.where,
+        result: returnValue
+      });
+      return returnValue;
+    },
+    updateMany: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      if (!whereClause) return 0;
+      const previousResults = await db.select().from(_table).where(whereClause);
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "update",
+        data: options.data,
+        where: options.where
+      });
+      for (const previousData of previousResults) {
+        await executeBeforeUpdateHooks(hooks, {
+          collection: _slug,
+          operation: "update",
+          data: options.data,
+          where: options.where,
+          previousData,
+          db
+        });
+      }
+      const result = await db.update(_table).set(options.data).where(whereClause);
+      for (const previousData of previousResults) {
+        await executeAfterUpdateHooks(hooks, {
+          collection: _slug,
+          operation: "update",
+          data: options.data,
+          where: options.where,
+          previousData,
+          db
+        });
+      }
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "update",
+        data: options.data,
+        where: options.where
+      });
+      return result.length || 0;
+    },
+    delete: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      if (!whereClause) return void 0;
+      const previousResult = await db.select().from(_table).where(whereClause).limit(1);
+      const previousData = previousResult[0];
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "delete",
+        where: options.where
+      });
+      await executeBeforeDeleteHooks(hooks, {
+        collection: _slug,
+        operation: "delete",
+        where: options.where,
+        previousData,
+        db
+      });
+      const result = await db.delete(_table).where(whereClause).returning();
+      const returnValue = options.returning ? result[0] : void 0;
+      await executeAfterDeleteHooks(hooks, {
+        collection: _slug,
+        operation: "delete",
+        where: options.where,
+        previousData,
+        result: returnValue,
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "delete",
+        where: options.where,
+        result: returnValue
+      });
+      return returnValue;
+    },
+    deleteMany: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      if (!whereClause) return 0;
+      const previousResults = await db.select().from(_table).where(whereClause);
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "delete",
+        where: options.where
+      });
+      for (const previousData of previousResults) {
+        await executeBeforeDeleteHooks(hooks, {
+          collection: _slug,
+          operation: "delete",
+          where: options.where,
+          previousData,
+          db
+        });
+      }
+      const result = await db.delete(_table).where(whereClause);
+      for (const previousData of previousResults) {
+        await executeAfterDeleteHooks(hooks, {
+          collection: _slug,
+          operation: "delete",
+          where: options.where,
+          previousData,
+          db
+        });
+      }
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "delete",
+        where: options.where
+      });
+      return result.length || 0;
+    },
+    count: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options?.where);
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options?.where
+      });
+      await executeBeforeReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        db
+      });
+      const result = whereClause ? await db.select().from(_table).where(whereClause) : await db.select().from(_table);
+      await executeAfterReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        result,
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options?.where,
+        result
+      });
+      return result.length;
+    },
+    exists: async (options) => {
+      const whereClause = buildWhereClause(tableColumns, options.where);
+      if (!whereClause) return false;
+      await executeBeforeOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options.where
+      });
+      await executeBeforeReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        db
+      });
+      const result = await db.select().from(_table).where(whereClause).limit(1);
+      const returnValue = result.length > 0;
+      await executeAfterReadHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        query: options,
+        result,
+        db
+      });
+      await executeAfterOperationHooks(hooks, {
+        collection: _slug,
+        operation: "read",
+        where: options.where,
+        result: returnValue
+      });
+      return returnValue;
+    }
+  };
+};
+
+// src/adapter.ts
+var pgAdapter = (config) => {
+  return {
+    type: "postgres",
+    config: {
+      url: config.url,
+      migrationsPath: config.migrationsPath ?? "./migrations"
+    }
+  };
+};
+
+// src/schema.ts
+var import_pg_core = require("drizzle-orm/pg-core");
+var buildTable = (collection2) => {
+  const columns = {
+    // Add default id column
+    id: (0, import_pg_core.serial)("id").primaryKey()
+  };
+  for (const [fieldName, fieldDef] of Object.entries(collection2.fields)) {
+    if (fieldName === "id") continue;
+    const fieldType2 = fieldDef.fieldType;
+    const fieldTypeName = fieldType2.name || fieldType2.type || "text";
+    switch (fieldTypeName) {
+      case "text":
+        columns[fieldName] = (0, import_pg_core.text)(fieldName);
+        break;
+      case "varchar":
+        columns[fieldName] = (0, import_pg_core.varchar)(fieldName, { length: 255 });
+        break;
+      case "number":
+      case "integer":
+        columns[fieldName] = (0, import_pg_core.integer)(fieldName);
+        break;
+      case "boolean":
+        columns[fieldName] = (0, import_pg_core.boolean)(fieldName);
+        break;
+      case "timestamp":
+        columns[fieldName] = (0, import_pg_core.timestamp)(fieldName);
+        break;
+      case "uuid":
+        columns[fieldName] = (0, import_pg_core.uuid)(fieldName);
+        break;
+      default:
+        columns[fieldName] = (0, import_pg_core.text)(fieldName);
+    }
+  }
+  return (0, import_pg_core.pgTable)(collection2.slug, columns);
+};
+var buildSchema = (collections) => {
+  const tables = {};
+  for (const coll of collections) {
+    tables[coll.slug] = buildTable(coll);
+  }
+  return tables;
+};
+
+// src/migrations.ts
+var push = async (_adapter, collections) => {
+  const schema = buildSchema(collections);
+  console.log("[TODO] Push schema with collections:", Object.keys(schema));
+};
+var generate = async (_adapter, collections) => {
+  const schema = buildSchema(collections);
+  console.log("[TODO] Generate migration with collections:", Object.keys(schema));
+};
+var migrate = async (adapter) => {
+  console.log("[TODO] Apply migrations from:", adapter.config.migrationsPath);
+};
+
+// src/config.ts
+var import_pg = require("pg");
+var import_node_postgres = require("drizzle-orm/node-postgres");
+var defineConfig = (options) => {
+  let pool = null;
+  let dbInstance = null;
+  let schema = {};
+  if (options.database.type === "postgres") {
+    pool = new import_pg.Pool({
+      connectionString: options.database.config.url
+    });
+    schema = buildSchema(options.collections);
+    dbInstance = (0, import_node_postgres.drizzle)(pool, { schema });
+  }
+  const collectionsMap = {};
+  const collectionNames = [];
+  for (const coll of options.collections) {
+    collectionsMap[coll.slug] = {
+      slug: coll.slug,
+      name: coll.name,
+      fields: coll.fields,
+      hooks: coll.hooks,
+      dataType: coll.dataType
+    };
+    collectionNames.push(coll.slug);
+  }
+  const pluginNames = [];
+  if (options.plugins) {
+    for (const plugin of options.plugins) {
+      pluginNames.push(plugin.name);
+      if (plugin.collections) {
+        for (const [name, coll] of Object.entries(plugin.collections)) {
+          collectionsMap[name] = {
+            slug: coll.slug,
+            name: coll.name,
+            fields: coll.fields,
+            hooks: coll.hooks,
+            dataType: coll.dataType
+          };
+          collectionNames.push(name);
+        }
+      }
+    }
+  }
+  return {
+    collections: collectionsMap,
+    db: dbInstance,
+    $meta: {
+      collections: collectionNames,
+      plugins: pluginNames
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  array,
+  boolean,
+  buildSchema,
+  buildTable,
+  collection,
+  createCollectionOperations,
+  date,
+  defineConfig,
+  email,
+  f,
+  field,
+  fieldType,
+  generate,
+  json,
+  migrate,
+  number,
+  pgAdapter,
+  push,
+  relation,
+  select,
+  text,
+  timestamp,
+  url
+});
+//# sourceMappingURL=index.js.map