@deessejs/collections 0.0.51 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,821 @@
+// 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
+import { z } from "zod";
+var getItemType = (itemSchema) => {
+  if (itemSchema instanceof z.ZodString) return "text";
+  if (itemSchema instanceof z.ZodNumber) return "integer";
+  if (itemSchema instanceof z.ZodBoolean) return "boolean";
+  if (itemSchema instanceof z.ZodDate) return "timestamp";
+  if (itemSchema instanceof z.ZodEnum) return "text";
+  if (itemSchema instanceof z.ZodArray) return "array";
+  if (itemSchema instanceof z.ZodObject) return "jsonb";
+  return "text";
+};
+var f = {
+  /**
+   * Text field type
+   */
+  text: () => fieldType({
+    schema: z.string(),
+    database: { type: "text" }
+  })(),
+  /**
+   * Email field type with built-in validation
+   */
+  email: () => fieldType({
+    schema: z.string().email(),
+    database: { type: "text" }
+  })(),
+  /**
+   * URL field type with built-in validation
+   */
+  url: () => fieldType({
+    schema: z.string().url(),
+    database: { type: "text" }
+  })(),
+  /**
+   * Number field type
+   */
+  number: () => fieldType({
+    schema: z.number(),
+    database: { type: "integer" }
+  })(),
+  /**
+   * Boolean field type
+   */
+  boolean: () => fieldType({
+    schema: z.boolean(),
+    database: { type: "boolean" }
+  })(),
+  /**
+   * Date field type (date only, no time)
+   */
+  date: () => fieldType({
+    schema: z.date(),
+    database: { type: "date" }
+  })(),
+  /**
+   * Timestamp field type (date with time)
+   */
+  timestamp: () => fieldType({
+    schema: z.date(),
+    database: { type: "timestamp" }
+  })(),
+  /**
+   * Creates a select field type
+   */
+  select: (options) => fieldType({
+    schema: z.enum(options),
+    database: { type: "text" }
+  })(),
+  /**
+   * JSON field type for storing JSON data
+   */
+  json: (schema) => fieldType({
+    schema: schema ?? z.any(),
+    database: { type: "jsonb" }
+  })(),
+  /**
+   * Array field type for storing lists
+   */
+  array: (itemSchema) => fieldType({
+    schema: 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 ? z.array(z.string()) : 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
+import { eq, and, like, gt, gte, lt, lte, isNull, inArray, not, desc, asc } from "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(eq(column, value));
+    } else {
+      const operator = value;
+      if ("eq" in operator) {
+        conditions.push(eq(column, operator.eq));
+      } else if ("neq" in operator) {
+        conditions.push(not(eq(column, operator.neq)));
+      } else if ("gt" in operator) {
+        conditions.push(gt(column, operator.gt));
+      } else if ("gte" in operator) {
+        conditions.push(gte(column, operator.gte));
+      } else if ("lt" in operator) {
+        conditions.push(lt(column, operator.lt));
+      } else if ("lte" in operator) {
+        conditions.push(lte(column, operator.lte));
+      } else if ("in" in operator) {
+        conditions.push(inArray(column, operator.in));
+      } else if ("notIn" in operator) {
+        conditions.push(not(inArray(column, operator.notIn)));
+      } else if ("contains" in operator) {
+        conditions.push(like(column, `%${operator.contains}%`));
+      } else if ("startsWith" in operator) {
+        conditions.push(like(column, `${operator.startsWith}%`));
+      } else if ("endsWith" in operator) {
+        conditions.push(like(column, `%${operator.endsWith}`));
+      } else if ("isNull" in operator) {
+        if (operator.isNull) {
+          conditions.push(isNull(column));
+        }
+      } else if ("not" in operator) {
+        conditions.push(not(eq(column, operator.not)));
+      }
+    }
+  }
+  if (conditions.length === 0) return void 0;
+  if (conditions.length === 1) return conditions[0];
+  return 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" ? desc(column) : asc(column);
+    }
+    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
+import { pgTable, serial, text as text2, timestamp as timestamp2, uuid, varchar, boolean as boolean2, integer } from "drizzle-orm/pg-core";
+var buildTable = (collection2) => {
+  const columns = {
+    // Add default id column
+    id: 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] = text2(fieldName);
+        break;
+      case "varchar":
+        columns[fieldName] = varchar(fieldName, { length: 255 });
+        break;
+      case "number":
+      case "integer":
+        columns[fieldName] = integer(fieldName);
+        break;
+      case "boolean":
+        columns[fieldName] = boolean2(fieldName);
+        break;
+      case "timestamp":
+        columns[fieldName] = timestamp2(fieldName);
+        break;
+      case "uuid":
+        columns[fieldName] = uuid(fieldName);
+        break;
+      default:
+        columns[fieldName] = text2(fieldName);
+    }
+  }
+  return 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
+import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+var defineConfig = (options) => {
+  let pool = null;
+  let dbInstance = null;
+  let schema = {};
+  if (options.database.type === "postgres") {
+    pool = new Pool({
+      connectionString: options.database.config.url
+    });
+    schema = buildSchema(options.collections);
+    dbInstance = 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
+    }
+  };
+};
+export {
+  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.mjs.map