@arcote.tech/arc 0.1.9 → 0.1.11

package/dist/context/context.d.ts

@@ -21,11 +21,15 @@ export type ArcCommandContext<E extends ArcContextElementAny[]> = ArcContextElem
 export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends false ? RemoveFalseAndResolvedPromiseFromArray<Rest> : First extends Promise<{
     default: infer Inner;
 }> ? RemoveFalseAndResolvedPromiseFromArray<[Inner, ...Rest]> : [First, ...RemoveFalseAndResolvedPromiseFromArray<Rest>] : [];
+export type FindElementByName<E extends ArcContextElementAny[], Name extends string> = E extends [
+    infer First extends ArcContextElementAny,
+    ...infer Rest extends ArcContextElementAny[]
+] ? First["name"] extends Name ? First : FindElementByName<Rest, Name> : never;
 export declare class ArcContext<const E extends ArcContextElementAny[]> {
     readonly elements: E;
     private elementsSet;
     constructor(elements: E);
-    get<Element extends E[number]>(name: Element["name"]): Element;
+    get<Name extends E[number]["name"]>(name: Name): FindElementByName<E, Name>;
     getSyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];
     getAsyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];
     pipe<const NewElements extends (ArcContextElementAny | false | Promise<{

package/dist/data-storage/store-state-master.d.ts

@@ -6,7 +6,7 @@ export declare class MasterStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
-    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>): Promise<{
+    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>, transactionCache?: Map<string, Item>): Promise<{
         from: Item | null;
         to: Item | null;
         event: ListenerEvent<Item>;

package/dist/elements/object.d.ts

@@ -1,7 +1,8 @@
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 import { type objectUtil, type util } from "../utils";
 import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import { ArcOptional } from "./optional";
 export declare type ArcRawShape = {
     [k: string]: ArcElement;
 };
@@ -64,13 +65,19 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>, V>;
     omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
     entries(): [string, ArcElement][];
+    keys(): (keyof E)[];
     toJsonSchema(): any;
     /** Generate database-agnostic column information */
     getColumnData(): DatabaseAgnosticColumnInfo;
     /** Merge this ArcObject with another shape */
     merge<OtherShape extends ArcRawShape>(otherShape: OtherShape): ArcObject<E & OtherShape, V>;
+    /** Create a partial version of this ArcObject where all fields are optional */
+    partial(): ArcObjectPartial<this>;
 }
 export type ArcObjectAny = ArcObject<any, any>;
+export type ArcObjectPartial<T extends ArcObjectAny> = T extends ArcObject<infer E, infer V> ? ArcObject<{
+    [K in keyof E]: ArcOptional<E[K]>;
+}, V> : never;
 export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E, any> ? Exclude<keyof E, symbol> : never;
 export type ArcObjectValueByKey<T extends ArcObjectAny, K extends ArcObjectKeys<T>> = T extends ArcObject<infer E, any> ? E[K] : never;
 export type ArcRawShapeType<Shape extends ArcRawShape> = {

package/dist/index.js

@@ -414,12 +414,17 @@ class ArcObject extends ArcAbstract {
   entries() {
     return Object.entries(this.rawShape);
   }
+  keys() {
+    return Object.keys(this.rawShape);
+  }
   toJsonSchema() {
     const properties = {};
     const required = [];
     for (const [key, element] of Object.entries(this.rawShape)) {
-      properties[key] = element.toJsonSchema?.() ?? {};
-      if (!(element instanceof ArcOptional)) {
+      if (element instanceof ArcOptional) {
+        properties[key] = element.parent.toJsonSchema?.() ?? {};
+      } else {
+        properties[key] = element.toJsonSchema?.() ?? {};
         required.push(key);
       }
     }
@@ -448,6 +453,13 @@ class ArcObject extends ArcAbstract {
     const mergedShape = { ...this.rawShape, ...otherShape };
     return new ArcObject(mergedShape);
   }
+  partial() {
+    const partialShape = Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
+      key,
+      element instanceof ArcOptional ? element : new ArcOptional(element)
+    ]));
+    return new ArcObject(partialShape);
+  }
 }
 function object(element) {
   return new ArcObject(element);
@@ -2129,10 +2141,13 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
-  async applyChangeAndReturnEvent(transaction, change) {
+  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
     if (change.type === "set") {
       await transaction.set(this.storeName, change.data);
       const item = this.deserialize ? this.deserialize(change.data) : change.data;
+      if (transactionCache) {
+        transactionCache.set(change.data._id, item);
+      }
       return {
         from: null,
         to: item,
@@ -2156,10 +2171,18 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "modify") {
-      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      let existing;
+      if (transactionCache && transactionCache.has(change.id)) {
+        existing = transactionCache.get(change.id);
+      } else {
+        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      }
       const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
+      if (transactionCache) {
+        transactionCache.set(change.id, item);
+      }
       return {
         from: null,
         to: item,
@@ -2171,10 +2194,18 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "mutate") {
-      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      let existing;
+      if (transactionCache && transactionCache.has(change.id)) {
+        existing = transactionCache.get(change.id);
+      } else {
+        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      }
       const updated = apply2(existing || {}, change.patches);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
+      if (transactionCache) {
+        transactionCache.set(change.id, item);
+      }
       return {
         from: null,
         to: item,
@@ -2189,16 +2220,18 @@ class MasterStoreState extends StoreState {
   }
   async applyChange(change) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
-    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
+    const transactionCache = new Map;
+    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change, transactionCache);
     await transaction.commit();
     this.notifyListeners([event3]);
     return { from, to };
   }
   async applyChanges(changes) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
+    const transactionCache = new Map;
     const events = [];
     for (const change of changes) {
-      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change);
+      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change, transactionCache);
       if (event3)
         events.push(event3);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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.",