@arcote.tech/arc 0.0.7 → 0.0.9

package/dist/collection/collection.d.ts

@@ -31,8 +31,8 @@ declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema ext
     commandContext(transaction: ReadTransaction, changes: CollectionChange[], getDraft: GetDraft<any>): {
         one: (id: util.GetType<Id>) => Deserialize<Id, Schema>;
         remove: (id: util.GetType<Id>) => Promise<any>;
-        add: (data: util.FirstArgument<Schema["parse"]>) => Promise<any>;
-        set: (id: util.GetType<Id>, data: util.FirstArgument<Schema["deserialize"]>) => Promise<any>;
+        add: (data: objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>) => Promise<any>;
+        set: (id: util.GetType<Id>, data: util.FirstArgument<Schema["serialize"]>) => Promise<any>;
     };
     applyChange(transaction: ReadWriteTransaction, change: CollectionChange, events: CollectionChange[]): Promise<void>;
     indexBy<Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {

package/dist/context/context.d.ts

@@ -26,6 +26,6 @@ declare class ArcContextWithCommands<const C extends ArcContextElement[], Cmds e
     constructor(context: C, commands: Cmds);
 }
 export type ArcContextAny = ArcContext<ArcContextElement[]>;
-export type ArcContextWithCommandsAny = ArcContextWithCommands<ArcContextElement[], any>;
+export type ArcContextWithCommandsAny = ArcContextWithCommands<any, any>;
 export declare function context<const C extends ArcContextElement[]>(...collections: C): ArcContext<C>;
 export {};

package/dist/elements/array.d.ts

@@ -1,6 +1,7 @@
 import { type util } from "../utils";
 import { ArcAbstract } from "./abstract";
-export declare class ArcArray<E extends ArcAbstract> extends ArcAbstract {
+import type { ArcElement } from "./element";
+export declare class ArcArray<E extends ArcElement> extends ArcAbstract {
     private parent;
     constructor(parent: E);
     parse(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["parse"]>[];
@@ -9,4 +10,4 @@ export declare class ArcArray<E extends ArcAbstract> extends ArcAbstract {
     deserializePath(path: string[], value: any): any;
 }
 export type ArcArrayAny = ArcArray<any>;
-export declare function array<E extends ArcAbstract>(element: E): ArcArray<E>;
+export declare function array<E extends ArcElement>(element: E): ArcArray<E>;

package/dist/elements/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./array";
+export * from "./boolean";
 export * from "./branded";
 export * from "./date";
 export * from "./id";

package/dist/index.js

@@ -569,6 +569,29 @@ class ArcArray extends ArcAbstract {
     return this.parent.deserialize(value);
   }
 }
+// elements/abstract-primitive.ts
+class ArcPrimitive extends ArcAbstract {
+  constructor() {
+    super();
+  }
+  serialize(value) {
+    return value;
+  }
+  parse(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+}
+
+// elements/boolean.ts
+function boolean() {
+  return new ArcBoolean;
+}
+
+class ArcBoolean extends ArcPrimitive {
+}
 // elements/date.ts
 function date() {
   return new ArcDate;
@@ -588,22 +611,6 @@ class ArcDate extends ArcAbstract {
     return new Date(value);
   }
 }
-// elements/abstract-primitive.ts
-class ArcPrimitive extends ArcAbstract {
-  constructor() {
-    super();
-  }
-  serialize(value) {
-    return value;
-  }
-  parse(value) {
-    return value;
-  }
-  deserialize(value) {
-    return value;
-  }
-}
-
 // elements/string.ts
 function string() {
   return new ArcString;
@@ -817,16 +824,21 @@ class RTCClient {
             console.error(`Collection ${collection3} not found`);
             return;
           }
-          const deserializedItems = items.map((item) => c.deserialize(item));
-          this.model.executeCommand(async (ctx) => {
-            for (const item of deserializedItems) {
-              const id3 = item._id;
-              if (!item)
-                await ctx[collection3].remove(id3);
-              else
-                await ctx[collection3].set(id3, item);
+          const deserializedItems = items.map((item) => {
+            if (item.deleted) {
+              return {
+                collection: collection3,
+                type: "delete",
+                id: item._id
+              };
             }
+            return {
+              collection: collection3,
+              type: "set",
+              body: item
+            };
           });
+          this.model.applyChanges(deserializedItems);
         }
         break;
       case "sync-done":
@@ -860,6 +872,7 @@ export {
   date,
   context,
   collection,
+  boolean,
   array2 as array,
   ArcStringEnum,
   ArcString,
@@ -872,5 +885,6 @@ export {
   ArcDate,
   ArcCollectionQuery,
   ArcBranded,
+  ArcBoolean,
   ArcArray
 };

package/dist/utils.d.ts

@@ -5,13 +5,13 @@ export declare namespace objectUtil {
     export type MergeShapes<U, V> = {
         [k in Exclude<keyof U, keyof V>]: U[k];
     } & V;
-    type optionalKeys<T extends object> = {
+    type optionalKeys<T extends any> = {
         [k in keyof T]: undefined extends T[k] ? k : never;
     }[keyof T];
-    type requiredKeys<T extends object> = {
+    type requiredKeys<T extends any> = {
         [k in keyof T]: undefined extends T[k] ? never : k;
     }[keyof T];
-    export type addQuestionMarks<T extends object> = simplify<{
+    export type addQuestionMarks<T extends any> = simplify<{
         [K in requiredKeys<T>]: T[K];
     } & {
         [K in optionalKeys<T>]?: T[K];
@@ -49,11 +49,14 @@ export type ContextTypes<Ctx extends {
 }> = Ctx["collections"] extends (ArcCollectionAny | ArcIndexedCollectionAny)[] ? {
     [Collection in Ctx["collections"][number] as `${Collection["name"]}.bodyWithoutId`]: util.GetType<Collection["schema"]>;
 } & {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.setBody`]: util.FirstArgument<Collection["schema"]["parse"]>;
+    [Collection in Ctx["collections"][number] as `${Collection["name"]}.setBody`]: objectUtil.addQuestionMarks<util.FirstArgument<Collection["schema"]["parse"]>>;
 } & {
     [Collection in Ctx["collections"][number] as `${Collection["name"]}.id`]: util.GetType<Collection["id"]>;
 } & {
     [Collection in Ctx["collections"][number] as `${Collection["name"]}.body`]: util.CollectionItemWithId<Collection>;
 } & {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.queryCollectionResult`]: QueryCollectionResult<Collection>;
+    [Collection in Ctx["collections"][number] as `${Collection["name"]}.queryCollectionResult`]: Omit<QueryCollectionResult<Collection>, "result">;
 } : never;
+export type infer<E extends {
+    deserialize: (...args: any) => any;
+}> = ReturnType<E["deserialize"]>;

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",