@arcote.tech/arc-utils 0.4.1

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@arcote.tech/arc-utils",
+  "type": "module",
+  "version": "0.4.1",
+  "private": false,
+  "description": "Reusable helpers for Arc framework — simpleAggregate and more",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc": "workspace:*",
+    "typescript": "^5.0.0"
+  }
+}

package/src/arc.d.ts

@@ -0,0 +1,6 @@
+declare const BROWSER: boolean;
+declare const NOT_ON_BROWSER: boolean;
+declare const ONLY_BROWSER: boolean;
+declare const SERVER: boolean;
+declare const NOT_ON_SERVER: boolean;
+declare const ONLY_SERVER: boolean;

package/src/index.ts

@@ -0,0 +1 @@
+export { simpleAggregate } from "./simple-aggregate";

package/src/simple-aggregate.ts

@@ -0,0 +1,65 @@
+import { aggregate, ArcOptional } from "@arcote.tech/arc";
+import type { ArcIdAny, ArcElement } from "@arcote.tech/arc";
+import type { ArcRawShape } from "@arcote.tech/arc";
+
+/** Make all schema fields optional by wrapping in ArcOptional */
+type OptionalShape<S extends ArcRawShape> = {
+  [K in keyof S]: ArcOptional<S[K]>;
+};
+
+function makeOptional<S extends ArcRawShape>(schema: S): OptionalShape<S> {
+  const result = {} as Record<string, ArcElement>;
+  for (const [key, field] of Object.entries(schema)) {
+    result[key] = field instanceof ArcOptional
+      ? field
+      : new ArcOptional(field);
+  }
+  return result as OptionalShape<S>;
+}
+
+/**
+ * Create a simple CRUD aggregate with auto-generated upsert event and update method.
+ *
+ * @example
+ * ```ts
+ * const Task = simpleAggregate("task", taskId, {
+ *   title: string(),
+ *   done: boolean(),
+ * });
+ * ```
+ */
+export function simpleAggregate<
+  const Name extends string,
+  Id extends ArcIdAny,
+  SchemaShape extends ArcRawShape,
+>(name: Name, id: Id, schema: SchemaShape) {
+  const eventName = `${name}Updated`;
+  const optionalSchema = makeOptional(schema);
+
+  return aggregate(name, id, schema)
+    .publicEvent(
+      eventName,
+      { _id: id, ...optionalSchema },
+      async (ctx, event) => {
+        const p = event.payload as Record<string, unknown>;
+        const idValue = p._id as any;
+        const partial: Record<string, unknown> = {};
+        for (const key of Object.keys(schema)) {
+          if (p[key] !== undefined) partial[key] = p[key];
+        }
+        if (await ctx.findOne({ _id: idValue })) {
+          await ctx.modify(idValue, partial as any);
+        } else {
+          await ctx.set(idValue, partial as any);
+        }
+      },
+    )
+    .mutateMethod(
+      "update",
+      { params: { _id: id, ...optionalSchema } },
+      ONLY_SERVER &&
+        (async (ctx, params) => {
+          await (ctx as any)[eventName].emit(params);
+        }),
+    );
+}