akanjs 2.0.0-rc.7 → 2.0.1

package/base/primitiveRegistry.ts

@@ -244,6 +244,18 @@ const scalarPrimitiveStatics = {
     value: PrimitiveValue,
     { optional = false }: { optional?: boolean } = {},
   ): PrimitiveValue {
+    if (optional && value === "") return undefined;
+    if (this.refName === "Date" && optional && typeof value === "string" && Number.isNaN(new Date(value).getTime()))
+      return undefined;
+    if (this.refName === "Date" && optional && value instanceof Date && Number.isNaN(value.getTime())) return undefined;
+    if (
+      optional &&
+      value &&
+      typeof value === "object" &&
+      "isValid" in value &&
+      !(value as { isValid: () => boolean }).isValid()
+    )
+      return undefined;
     this._checkValue(value, { optional });
     if (value === null || value === undefined) return undefined;
     return this.serializeValue(value);
@@ -257,6 +269,18 @@ const scalarPrimitiveStatics = {
       if (optional) return;
       else throw new Error(`Required ${this.refName} value: ${value}`);
     }
+    if (optional && value === "") return;
+    if (this.refName === "Date" && optional && typeof value === "string" && Number.isNaN(new Date(value).getTime()))
+      return;
+    if (this.refName === "Date" && optional && value instanceof Date && Number.isNaN(value.getTime())) return;
+    if (
+      optional &&
+      value &&
+      typeof value === "object" &&
+      "isValid" in value &&
+      !(value as { isValid: () => boolean }).isValid()
+    )
+      return;
     if (!this.validate(value)) throw new Error(`Invalid ${this.refName} value: ${value}`);
   },
 };
@@ -307,8 +331,10 @@ Object.assign(Date, {
   parseValue(input: Date | string | number | Dayjs) {
     return dayjs(input);
   },
-  serializeValue(value: Dayjs | Date) {
-    return value instanceof Date ? value : value.toDate();
+  serializeValue(value: Dayjs | Date | string | number) {
+    if (value instanceof Date) return value;
+    if (typeof value === "string" || typeof value === "number") return dayjs(value).toDate();
+    return value.toDate();
   },
 });
 PrimitiveRegistry.register(Date);

package/cli/application/application.command.ts

@@ -1,5 +1,5 @@
 import { select } from "@inquirer/prompts";
-import { App, command, Exec, Sys, Workspace } from "akanjs/devkit";
+import { App, command, Exec, getMobileTargetChoices, Sys, Workspace } from "akanjs/devkit";
 
 import { ApplicationScript } from "./application.script";
 
@@ -53,7 +53,11 @@ export class ApplicationCommand extends command("application", [ApplicationScrip
     }),
   buildIos: target({ short: true, desc: "Build iOS app with Capacitor" })
     .with(App)
-    .option("target", String, { desc: "mobile target name or all" })
+    .option("target", String, {
+      desc: "mobile target name or all",
+      ask: "Select mobile target",
+      enum: async ({ app }) => await getMobileTargetChoices(app),
+    })
     .option("env", String, {
       enum: ["local", "debug", "develop", "main"],
       desc: "backend environment",
@@ -66,7 +70,11 @@ export class ApplicationCommand extends command("application", [ApplicationScrip
     }),
   buildAndroid: target({ short: true, desc: "Build Android app with Capacitor" })
     .with(App)
-    .option("target", String, { desc: "mobile target name or all" })
+    .option("target", String, {
+      desc: "mobile target name or all",
+      ask: "Select mobile target",
+      enum: async ({ app }) => await getMobileTargetChoices(app),
+    })
     .option("env", String, {
       enum: ["local", "debug", "develop", "main"],
       desc: "backend environment",

package/cli/application/application.runner.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { confirm, input, select } from "@inquirer/prompts";
 import { StringOutputParser } from "@langchain/core/output_parsers";
 import { PromptTemplate } from "@langchain/core/prompts";
@@ -15,6 +16,7 @@ import {
   CapacitorApp,
   type DatabaseMode,
   type Exec,
+  LibExecutor,
   type MobileEnv,
   type ReleaseSourceOptions,
   type ResolvedMobileTarget,
@@ -73,7 +75,21 @@ export class ApplicationRunner extends runner("application") {
     await new ApplicationBuildRunner(app).typecheck(options);
   }
   async test(exec: Exec) {
-    await exec.spawn("bun", ["test", "--isolate"], { stdio: "inherit" });
+    const isSignalTarget = exec instanceof AppExecutor || exec instanceof LibExecutor;
+    const preloadPath = path.join(exec.cwdPath, "../../pkgs/akanjs/test/signalTest.preload.ts");
+    const env = isSignalTarget
+      ? {
+          AKAN_TEST_SIGNAL: "1",
+          AKAN_TEST_TARGET_TYPE: exec.type,
+          AKAN_TEST_TARGET_NAME: exec.name,
+          AKAN_TEST_LIBS: exec.getScanInfo({ allowEmpty: true })?.getLibs().join(",") ?? "",
+        }
+      : {};
+    const args = isSignalTarget ? ["test", "--isolate", "--preload", preloadPath] : ["test", "--isolate"];
+    await exec.spawn("bun", args, {
+      ...(isSignalTarget ? { env: { ...process.env, ...env } } : {}),
+      stdio: "inherit",
+    });
   }
   async build(
     app: App,

package/cli/guidelines/databaseModule/databaseModule.instruction.md

@@ -94,7 +94,7 @@ Create the MongoDB schema with document methods and middleware:
 
 ```typescript
 import { dayjs } from "akanjs/base";
-import { beyond, by, Database, into, Loader, type SchemaOf } from "akanjs/document";
+import { by, Database, into, Loader, type SchemaOf } from "akanjs/document";
 import { hashPassword } from "@libs/shared/server";
 
 import * as cnst from "../cnst";

package/cli/guidelines/modelConstant/modelConstant.instruction.md

@@ -80,7 +80,7 @@ export class Drone extends Full(DroneObject, LightDrone) {
 // 7. Insight Model
 
 export class DroneInsight {
-  @Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
+  @Field.Prop(() => Int, { default: 0, accumulate: {} })
   count: number;
 }
 
@@ -223,7 +223,7 @@ Insight model defines statistical fields:
 
 ```typescript
 export class DroneInsight {
-  @Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
+  @Field.Prop(() => Int, { default: 0, accumulate: {} })
   count: number;
 }
 ```
@@ -314,8 +314,8 @@ const drones = await this.listByName("myDrone", { sort: "alphabetical" });
 | `enum`       | `any[]`              | -       | Enum values restriction                | `@Field.Prop(()=> String, { enum: ["active","inactive"] }) status;`    |
 | `minlength`  | `number`             | -       | Minimum string length                  | `@Field.Prop(()=> String, { minlength: 2 }) name: string;`             |
 | `maxlength`  | `number`             | -       | Maximum string length                  | `@Field.Prop(()=> String, { maxlength: 30 }) title: string;`           |
-| `query`      | `object`             | -       | Query value for Summary fields         | `@Field.Prop(() => Int, { query: { status: { $ne: 'inactive' } })`     |
-| `accumulate` | `object`             | -       | Aggregation value for Insight fields   | `@Field.Prop(() => Int, { accumulate: { $sum: 1 } }) count: number;`   |
+| `query`      | `object`             | -       | Query value for Summary fields         | `@Field.Prop(() => Int, { query: { status: { ne: "inactive" } } })`     |
+| `accumulate` | `object`             | -       | Document query filter for Insight count fields | `@Field.Prop(() => Int, { accumulate: { status: "active" } }) activeCount: number;` |
 | `example`    | `any`                | -       | Example value for API docs             | `@Field.Prop(()=> String, { example: "contact@akanjs.com" }) email;`   |
 | `of`         | `any`                | -       | Value type for Map fields              | `@Field.Prop(()=> Map, { of: Date }) readAts: Map<string, Dayjs>;`     |
 | `validate`   | `(value) => boolean` | -       | Custom validation function             | `@Field.Prop(()=> String, { validate: (v)=> v.includes("@") }) email;` |
@@ -477,7 +477,7 @@ export class Drone extends Full(DroneObject, LightDrone) {
 // Insight Model
 
 export class DroneInsight {
-  @Field.Prop(() => Int, { accumulate: { $sum: 1 } })
+  @Field.Prop(() => Int, { accumulate: {} })
   count: number;
 }
 

package/cli/guidelines/modelDocument/modelDocument.instruction.md

@@ -118,26 +118,14 @@ export class OrderModel extends into(Order, cnst.orderCnst) {
       .save();
   }
 
-  // Aggregation example
+  // Insight-style count example
   async getOrderStatsByUser(userId: string) {
-    const result = await this.Order.aggregate([
-      { $match: { user: userId } },
-      {
-        $group: {
-          _id: "$status",
-          count: { $sum: 1 },
-          totalAmount: { $sum: "$totalAmount" },
-        },
-      },
-    ]);
-
-    return result.reduce((acc, item) => {
-      acc[item._id] = {
-        count: item.count,
-        totalAmount: item.totalAmount,
-      };
-      return acc;
-    }, {});
+    const baseQuery = { user: userId };
+
+    return {
+      active: await this.count({ ...baseQuery, status: "active" }),
+      refunded: await this.count({ ...baseQuery, status: "refunded" }),
+    };
   }
 }
 ```
@@ -191,37 +179,30 @@ Indexes are crucial for query performance. Define them in the Middleware's `onSc
 - **Unique index** - Ensure field values are unique across the collection
 - **Sparse index** - Only include documents that have the indexed field
 
-## How to Use MongoDB Model
+## How to Query Documents
 
-The Akan.js framework provides direct access to the Mongoose model, allowing you to perform standard MongoDB operations:
+The Akan.js framework uses document query objects for common filtering and counting:
 
 ```typescript
 // Find operations
-const product = await productModel.Product.findById(id);
-const activeProducts = await productModel.Product.find({ status: "active" });
+const product = await productModel.pickById(id);
+const activeProducts = await productModel.list({ status: "active" });
 
 // Update operations
-await productModel.Product.updateMany({ category: "electronics" }, { $set: { onSale: true } });
+await productModel.updateManyByQuery({ category: "electronics" }, { set: { onSale: true } });
 
-// Aggregation
-const stats = await productModel.Product.aggregate([
-  { $match: { status: "active" } },
-  {
-    $group: {
-      _id: "$category",
-      count: { $sum: 1 },
-      avgPrice: { $avg: "$price" },
-    },
-  },
-]);
+// Insight counts
+const activeCount = await productModel.count({ status: "active" });
+const categoryCount = await productModel.count({ category: "electronics" });
 
 // Advanced querying
-const products = await productModel.Product.find({
-  price: { $gte: 100, $lte: 500 },
-  category: { $in: ["electronics", "gadgets"] },
-})
-  .sort({ rating: -1 })
-  .limit(10);
+const products = await productModel.list(
+  {
+    price: { gte: 100, lte: 500 },
+    category: { oneOf: ["electronics", "gadgets"] },
+  },
+  { sort: { rating: -1 }, limit: 10 },
+);
 ```
 
 ## How to Use DataLoader
@@ -422,16 +403,17 @@ export class ProductModel extends into(Product, cnst.productCnst) {
   tagProductsLoader: Loader<string, Product[]>;
 
   async findPopularProducts(limit = 10) {
-    return this.Product.find({
+    return this.list(
+      {
       status: "active",
-      popularity: { $gte: 4 },
-    })
-      .sort({ popularity: -1 })
-      .limit(limit);
+        popularity: { gte: 4 },
+      },
+      { sort: { popularity: -1 }, limit },
+    );
   }
 
   async updatePrices(categoryId: string, increasePercentage: number) {
-    const products = await this.Product.find({ category: categoryId });
+    const products = await this.list({ category: categoryId });
 
     const updates = products.map((product) => {
       const newPrice = product.price * (1 + increasePercentage / 100);
@@ -441,20 +423,11 @@ export class ProductModel extends into(Product, cnst.productCnst) {
     return Promise.all(updates);
   }
 
-  async getCategoryStats() {
-    const result = await this.Product.aggregate([
-      { $match: { status: "active" } },
-      {
-        $group: {
-          _id: "$category",
-          count: { $sum: 1 },
-          avgPrice: { $avg: "$price" },
-          minPrice: { $min: "$price" },
-          maxPrice: { $max: "$price" },
-        },
-      },
-      { $sort: { count: -1 } },
-    ]);
+  async getCategoryStats(categoryId: string) {
+    const result = {
+      activeCount: await this.count({ status: "active", category: categoryId }),
+      popularCount: await this.count({ status: "active", category: categoryId, popularity: { gte: 4 } }),
+    };
 
     // Cache the results
     await this.ProductCache.set("stats", "categories", JSON.stringify(result), { expireAt: dayjs().add(1, "hour") });

package/cli/guidelines/modelService/modelService.instruction.md

@@ -644,7 +644,7 @@ export class OrderService extends DbService(db.orderDb) {
     // Return stock to inventory
     for (const item of order.items) {
       await this.productService.updateProduct(item.product, {
-        $inc: { stock: item.quantity },
+        inc: { stock: item.quantity },
       });
     }