sluice-orm 0.1.1 → 0.2.0

package/README.md

@@ -4,10 +4,12 @@
 
 **Type-safe MongoDB aggregation pipeline builder** where every stage's output type becomes the next stage's input — fully inferred, zero runtime overhead.
 
+📚 **[Full Documentation](https://drttnk.github.io/sluice-orm/)** | 📖 **[Advanced Typings Showcase](https://drttnk.github.io/sluice-orm/docs/advanced-typings)**
+
 ```typescript
 const result = await users
   .aggregate(
-    $match(() => ({ age: { $gte: 18 } })),
+    $match($ => ({ age: { $gte: 18 } })),
     $group($ => ({
       _id: "$department",
       avgAge: $.avg("$age"),
@@ -16,7 +18,7 @@ const result = await users
     $sort({ headcount: -1 }),
   )
   .toList();
-// result: { _id: string; avgAge: number; headcount: number }[]
+// result: { _id: string; avgAge: number | null; headcount: number }[]
 ```
 
 **What makes it different:** every `$field` reference, every expression operator, every accumulator is validated against your document schema at compile time. `$.multiply("$name", 2)` won't compile — it knows `name` is a `string`.
@@ -105,6 +107,37 @@ await users.bulkWrite([
 ]);
 ```
 
+---
+
+## Effect Support
+
+For teams using [Effect](https://effect.website/), Sluice provides a dedicated `registryEffect` that wraps all operations in `Effect.Effect`.
+
+```typescript
+import { Effect } from "effect";
+import { registryEffect } from "sluice-orm";
+
+const db = registryEffect("8.0", { users: UserSchema })(client.db("myapp"));
+
+// All operations return Effect.Effect<T, Error>
+const findEffect = db.users.find(() => ({ age: { $gte: 18 } })).toOne();
+const user = await Effect.runPromise(findEffect);
+
+// Compose multiple operations
+const program = Effect.gen(function* () {
+  yield* db.users.insertOne({ _id: "u1", name: "Alice", age: 30 }).execute();
+  const user = yield* db.users.find(() => ({ _id: "u1" })).toOne();
+  yield* db.users.updateOne(() => ({ _id: "u1" }), { $inc: { age: 1 } }).execute();
+  const updated = yield* db.users.find(() => ({ _id: "u1" })).toOne();
+  return { before: user?.age, after: updated?.age };
+});
+
+const result = await Effect.runPromise(program);
+// result: { before: 30, after: 31 }
+```
+
+---
+
 ### Update pipelines
 
 ```typescript
@@ -174,18 +207,18 @@ $project($ => ({
 ## Running Tests
 
 ```bash
-# Full test suite (type checks + runtime tests)
-npm test
+# Type checks only (what CI runs)
+npm run test:types
 
 # Runtime tests only
 npm run test:runtime
 
-# Type checks only
-npm run test:types
+# Full test suite (format + type checks + runtime tests — precommit)
+npm test
 ```
 
 ## Build
 
 ```bash
-npm run build:ci
+npm run build
 ```

package/dist/index.cjs

@@ -57,12 +57,17 @@ __export(index_exports, {
   $unwind: () => $unwind,
   AccumulatorBuilder: () => AccumulatorBuilder,
   ExprBuilder: () => ExprBuilder,
+  MongoDbClient: () => MongoDbClient,
+  MongoError: () => MongoError,
   Ret: () => Ret,
   WindowBuilder: () => WindowBuilder,
   collection: () => collection,
+  collectionEffect: () => collectionEffect,
   functionToString: () => functionToString,
+  makeMongoDbClientLayer: () => makeMongoDbClientLayer,
   migrate: () => migrate,
   registry: () => registry,
+  registryEffect: () => registryEffect,
   resolveAccumulator: () => resolveAccumulator
 });
 module.exports = __toCommonJS(index_exports);
@@ -929,6 +934,195 @@ var registry = (version, schemas) => (client) => {
     Object.entries(schemas).map(([name, schema]) => [name, bind(name, schema)])
   );
 };
+
+// src/registryEffect.ts
+var import_effect = require("effect");
+var MongoError = class extends import_effect.Data.TaggedError("MongoError") {
+};
+var MongoDbClient = class extends import_effect.Context.Tag("MongoDbClient")() {
+};
+var wrapMongoOperation = (operation, fn) => import_effect.Effect.tryPromise({
+  try: fn,
+  catch: (cause) => new MongoError({
+    operation,
+    cause,
+    message: cause instanceof Error ? cause.message : String(cause)
+  })
+});
+function createCrudMethodsEffect(mongoCol) {
+  const extractFilter = (filterFn) => {
+    if (!filterFn) return {};
+    return filterFn({});
+  };
+  return {
+    find: ((filterFn, options) => ({
+      toList: () => wrapMongoOperation("find.toList", () => {
+        const filter = filterFn ? extractFilter(filterFn) : {};
+        let cursor = mongoCol.find(filter);
+        if (options?.sort) cursor = cursor.sort(options.sort);
+        if (options?.skip) cursor = cursor.skip(options.skip);
+        if (options?.limit) cursor = cursor.limit(options.limit);
+        if (options?.projection) cursor = cursor.project(options.projection);
+        if (options?.hint) cursor = cursor.hint(options.hint);
+        if (options?.maxTimeMS) cursor = cursor.maxTimeMS(options.maxTimeMS);
+        if (options?.collation) cursor = cursor.collation(options.collation);
+        if (options?.comment) cursor = cursor.comment(options.comment);
+        return cursor.toArray();
+      }),
+      toOne: () => wrapMongoOperation("find.toOne", () => {
+        const filter = filterFn ? extractFilter(filterFn) : {};
+        return mongoCol.findOne(
+          filter,
+          options
+        );
+      })
+    })),
+    findOne: ((filterFn, options) => ({
+      toList: () => wrapMongoOperation("findOne.toList", async () => {
+        const doc = await mongoCol.findOne(
+          filterFn ? extractFilter(filterFn) : {},
+          options
+        );
+        return doc ? [doc] : [];
+      }),
+      toOne: () => wrapMongoOperation(
+        "findOne.toOne",
+        () => mongoCol.findOne(
+          filterFn ? extractFilter(filterFn) : {},
+          options
+        )
+      )
+    })),
+    insertOne: (doc) => ({
+      execute: () => wrapMongoOperation("insertOne", () => mongoCol.insertOne(doc))
+    }),
+    insertMany: (docs) => ({
+      execute: () => wrapMongoOperation("insertMany", () => mongoCol.insertMany(docs))
+    }),
+    updateOne: ((filterFn, updateArg, options) => {
+      const filter = extractFilter(filterFn);
+      const updateDoc = typeof updateArg === "function" ? updateArg(update()).stages : updateArg;
+      return {
+        execute: () => wrapMongoOperation(
+          "updateOne",
+          () => mongoCol.updateOne(filter, updateDoc, options)
+        )
+      };
+    }),
+    updateMany: ((filterFn, updateArg, options) => {
+      const filter = extractFilter(filterFn);
+      const updateDoc = typeof updateArg === "function" ? updateArg(update()).stages : updateArg;
+      return {
+        execute: () => wrapMongoOperation(
+          "updateMany",
+          () => mongoCol.updateMany(filter, updateDoc, options)
+        )
+      };
+    }),
+    replaceOne: ((filterFn, replacement, options) => ({
+      execute: () => wrapMongoOperation(
+        "replaceOne",
+        () => mongoCol.replaceOne(
+          extractFilter(filterFn),
+          replacement,
+          options
+        )
+      )
+    })),
+    deleteOne: ((filterFn) => ({
+      execute: () => wrapMongoOperation("deleteOne", () => mongoCol.deleteOne(extractFilter(filterFn)))
+    })),
+    deleteMany: ((filterFn) => ({
+      execute: () => wrapMongoOperation("deleteMany", () => mongoCol.deleteMany(extractFilter(filterFn)))
+    })),
+    findOneAndDelete: ((filterFn, options) => ({
+      execute: () => wrapMongoOperation(
+        "findOneAndDelete",
+        () => mongoCol.findOneAndDelete(extractFilter(filterFn), options).then((r) => r)
+      )
+    })),
+    findOneAndReplace: ((filterFn, replacement, options) => ({
+      execute: () => wrapMongoOperation(
+        "findOneAndReplace",
+        () => mongoCol.findOneAndReplace(
+          extractFilter(filterFn),
+          replacement,
+          options
+        ).then((r) => r)
+      )
+    })),
+    findOneAndUpdate: ((filterFn, updateArg, options) => ({
+      execute: () => wrapMongoOperation(
+        "findOneAndUpdate",
+        () => mongoCol.findOneAndUpdate(
+          extractFilter(filterFn),
+          updateArg,
+          options
+        ).then((r) => r)
+      )
+    })),
+    countDocuments: ((filterFn, options) => ({
+      execute: () => wrapMongoOperation(
+        "countDocuments",
+        () => mongoCol.countDocuments(
+          filterFn ? extractFilter(filterFn) : {},
+          options
+        )
+      )
+    })),
+    estimatedDocumentCount: () => ({
+      execute: () => wrapMongoOperation("estimatedDocumentCount", () => mongoCol.estimatedDocumentCount())
+    }),
+    distinct: ((field, filterFn) => ({
+      execute: () => wrapMongoOperation(
+        "distinct",
+        () => mongoCol.distinct(field, filterFn ? extractFilter(filterFn) : {})
+      )
+    })),
+    bulkWrite: ((operations, options) => ({
+      execute: () => wrapMongoOperation(
+        "bulkWrite",
+        () => mongoCol.bulkWrite(operations, options)
+      )
+    }))
+  };
+}
+var collectionEffect = (name, _schema, mongoCol) => {
+  const col = {
+    __collectionName: name,
+    __collectionType: {}
+  };
+  const crud = createCrudMethodsEffect(mongoCol);
+  return Object.assign(col, {
+    aggregate: ((...stages) => {
+      let agg = { collectionName: name, stages: [] };
+      for (const s of stages) {
+        agg = s(agg);
+      }
+      return {
+        ...agg,
+        toList: () => wrapMongoOperation(
+          "aggregate",
+          () => mongoCol.aggregate(agg.stages).toArray()
+        ),
+        toMQL: () => JSON.stringify(agg.stages, null, 2)
+      };
+    }),
+    ...crud
+  });
+};
+var registryEffect = (_version, schemas) => import_effect.Effect.gen(function* () {
+  const { db: client } = yield* MongoDbClient;
+  const bind = (name, schema) => collectionEffect(
+    name,
+    schema,
+    client.collection(name)
+  );
+  return Object.fromEntries(
+    Object.entries(schemas).map(([name, schema]) => [name, bind(name, schema)])
+  );
+});
+var makeMongoDbClientLayer = (db) => import_effect.Layer.succeed(MongoDbClient, { db });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $addFields,
@@ -966,12 +1160,17 @@ var registry = (version, schemas) => (client) => {
   $unwind,
   AccumulatorBuilder,
   ExprBuilder,
+  MongoDbClient,
+  MongoError,
   Ret,
   WindowBuilder,
   collection,
+  collectionEffect,
   functionToString,
+  makeMongoDbClientLayer,
   migrate,
   registry,
+  registryEffect,
   resolveAccumulator
 });
 //# sourceMappingURL=index.cjs.map