@arcote.tech/arc 0.4.6 → 0.4.8

package/dist/context/context.d.ts

@@ -16,6 +16,16 @@ export declare class ArcContext<const Elements extends ArcContextElement<any>[]>
      * @returns The element if found, undefined otherwise
      */
     get<E extends Elements[number]>(name: E["name"]): E | undefined;
+    /**
+     * Replace a context element by name with a new element.
+     *
+     * @example
+     * ```typescript
+     * const accounts = ctx.get("userAccounts")!;
+     * const seeded = ctx.replace("userAccounts", accounts.withSeeds([...]));
+     * ```
+     */
+    replace(name: Elements[number]["name"], element: ArcContextElementAny): ArcContext<Elements>;
 }
 /**
  * Create a new context from an array of elements

package/dist/context-element/aggregate/aggregate-base.d.ts

@@ -9,7 +9,7 @@ import type { ArcObjectAny } from "../../elements/object";
 import type { ModelAdapters } from "../../model/model-adapters";
 import type { $type } from "../../utils/types/get-type";
 import type { ArcViewItem } from "../view/view-context";
-import type { AggregateInstanceCtx } from "./aggregate-builder";
+import type { AggregateInstanceCtx } from "./aggregate-element";
 import type { AggregateEventEntry } from "./aggregate-data";
 /**
  * Base class for aggregate instances.

package/dist/context-element/aggregate/aggregate-builder.d.ts

@@ -1,139 +1,12 @@
+/**
+ * aggregate() — entry point for creating aggregate context elements.
+ *
+ * Returns an ArcAggregateElement directly (no .build() needed).
+ * Chain methods like .publicEvent(), .mutateMethod(), .clientQuery(), .seedWith()
+ * to configure the aggregate — each returns a new immutable instance.
+ */
+import { ArcObject, type ArcRawShape } from "../../elements/object";
 import type { ArcIdAny } from "../../elements/id";
-import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../../elements/object";
-import type { ArcTokenAny } from "../../token/token";
-import type { $type } from "../../utils/types/get-type";
-import type { Simplify } from "../../utils";
-import { ArcEvent, type ArcEventAny } from "../event/event";
-import type { ArcEventInstance } from "../event/instance";
-import type { ArcViewHandlerContext } from "../view/view-context";
-import type { ViewProtection, ViewProtectionFn } from "../view/view-data";
-import { AggregateBase } from "./aggregate-base";
-import type { AggregateCronMethodEntry, AggregateEventEntry, AggregateMutateMethodEntry, AggregateQueryMethodEntry } from "./aggregate-data";
-type InlineArcEvent<EN extends string, PS extends ArcRawShape> = ArcEvent<{
-    name: EN;
-    payload: ArcObject<PS>;
-    protections: [];
-}>;
-type AggregateRow<Id extends ArcIdAny, Schema extends ArcObjectAny> = Simplify<$type<Schema> & {
-    _id: $type<Id>;
-}>;
-type AggregatePrivateQuery<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
-    find: (options?: any) => Promise<AggregateRow<Id, Schema>[]>;
-    findOne: (where?: any) => Promise<AggregateRow<Id, Schema> | undefined>;
-};
-type MutateMethodContext<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
-    [E in Events[number] as E["event"]["name"]]: {
-        emit: (payload: E["event"]["payload"] extends {
-            deserialize: (...a: any) => any;
-        } ? $type<E["event"]["payload"]> : undefined) => Promise<void>;
-    };
-} & {
-    $auth: {
-        params: any;
-        tokenName: string;
-    };
-    $query: AggregatePrivateQuery<Id, Schema>;
-};
-type ClientQueryContext<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
-    $query: {
-        find: {
-            <M extends new (row: AggregateRow<Id, Schema>, adapters: any) => any>(options: any, mapper: M): Promise<InstanceType<M>[]>;
-            (options?: any): Promise<AggregateRow<Id, Schema>[]>;
-        };
-        findOne: {
-            <M extends new (row: AggregateRow<Id, Schema>, adapters: any) => any>(where: any, mapper: M): Promise<InstanceType<M> | undefined>;
-            (where?: any): Promise<AggregateRow<Id, Schema> | undefined>;
-        };
-    };
-    $auth: {
-        params: any;
-        tokenName: string;
-    };
-};
-export type AggregateInstanceCtx<Events extends AggregateEventEntry[]> = {
-    [E in Events[number] as E["event"]["name"]]: {
-        emit: (payload: E["event"]["payload"] extends {
-            deserialize: (...a: any) => any;
-        } ? $type<E["event"]["payload"]> : undefined) => Promise<void>;
-    };
-};
-type PublicEvents<Events extends AggregateEventEntry[]> = Extract<Events[number], {
-    isPublic: true;
-}>;
-type PublicEventNames<Events extends AggregateEventEntry[]> = PublicEvents<Events>["event"]["name"];
-type GetPublicEvent<Events extends AggregateEventEntry[], Name extends string> = Extract<PublicEvents<Events>, {
-    event: {
-        name: Name;
-    };
-}>["event"];
-export declare class AggregateBuilder<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[], MutateMethods extends AggregateMutateMethodEntry[], QueryMethods extends AggregateQueryMethodEntry[] = []> {
-    private readonly _name;
-    private readonly _id;
-    private readonly _schema;
-    private readonly _events;
-    private readonly _protections;
-    private readonly _mutateMethods;
-    private readonly _queryMethods;
-    constructor(name: Name, id: Id, schema: Schema, events?: Events, protections?: ViewProtection[], mutateMethods?: MutateMethods, queryMethods?: QueryMethods);
-    protectBy<T extends ArcTokenAny>(token: T, protectionFn: ViewProtectionFn<any>): AggregateBuilder<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
-    event<const EventName extends string, PayloadShape extends ArcRawShape>(eventName: EventName, payload: PayloadShape, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<InlineArcEvent<EventName, PayloadShape>>) => Promise<void>): AggregateBuilder<Name, Id, Schema, [
-        ...Events,
-        AggregateEventEntry<InlineArcEvent<EventName, PayloadShape>, Id, Schema, false>
-    ], MutateMethods, QueryMethods>;
-    publicEvent<const EventName extends string, PayloadShape extends ArcRawShape>(eventName: EventName, payload: PayloadShape, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<InlineArcEvent<EventName, PayloadShape>>) => Promise<void>): AggregateBuilder<Name, Id, Schema, [
-        ...Events,
-        AggregateEventEntry<InlineArcEvent<EventName, PayloadShape>, Id, Schema, true>
-    ], MutateMethods, QueryMethods>;
-    handleEvent<E extends ArcEventAny>(arcEvent: E, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<E>) => Promise<void>): AggregateBuilder<Name, Id, Schema, [
-        ...Events,
-        AggregateEventEntry<E, ArcIdAny, ArcObjectAny, false>
-    ], MutateMethods, QueryMethods>;
-    mutateMethod<const MethodName extends string, ParamsShape extends ArcRawShape, HR = void, R = never>(methodName: MethodName, config: {
-        params: ParamsShape;
-        result?: R;
-    }, handler: ((ctx: MutateMethodContext<Id, Schema, Events>, params: $type<ArcObject<ParamsShape>>) => Promise<HR>) | false): AggregateBuilder<Name, Id, Schema, Events, [
-        ...MutateMethods,
-        {
-            name: MethodName;
-            params: ArcObject<ParamsShape>;
-            handler: typeof handler;
-            handlerReturn: HR;
-            result: R;
-        }
-    ], QueryMethods>;
-    /**
-     * Attach a cron schedule to the last declared mutateMethod.
-     * The CronScheduler will call this method on the given schedule
-     * for every existing aggregate instance.
-     *
-     * @param expression - A cron expression (e.g. "0 *\/6 * * *" for every 6 hours)
-     */
-    cron(expression: string): AggregateBuilder<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
-    clientQuery<const MethodName extends string, H extends (ctx: ClientQueryContext<Id, Schema>, ...args: any[]) => Promise<any>>(methodName: MethodName, handler: H): AggregateBuilder<Name, Id, Schema, Events, MutateMethods, [
-        ...QueryMethods,
-        {
-            name: MethodName;
-            handler: H;
-        }
-    ]>;
-    build(): AggregateConstructor<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
-}
-export type AggregateConstructor<Name extends string = string, Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, Events extends AggregateEventEntry[] = AggregateEventEntry[], MutateMethods extends AggregateMutateMethodEntry[] = AggregateMutateMethodEntry[], QueryMethods extends AggregateQueryMethodEntry[] = AggregateQueryMethodEntry[]> = (new (row: import("../view/view-context").ArcViewItem<Id, Schema>, adapters: import("../../model/model-adapters").ModelAdapters) => AggregateBase<Id, Schema, Events>) & {
-    readonly __aggregateName: Name;
-    readonly __aggregateId: Id;
-    readonly __aggregateSchema: Schema;
-    readonly __aggregateEvents: Events;
-    readonly __aggregateProtections: ViewProtection[];
-    readonly __aggregateMutateMethods: MutateMethods;
-    readonly __aggregateQueryMethods: QueryMethods;
-    readonly __aggregateCronMethods: AggregateCronMethodEntry[];
-    getEvent<EventName extends PublicEventNames<Events>>(name: EventName): GetPublicEvent<Events, EventName>;
-};
-export type AggregateConstructorAny = AggregateConstructor<any, any, any, any, any, any>;
-/** Extract the full row type ({ _id, ...fields }) from an aggregate constructor. */
-export type AggregateData<Ctor extends AggregateConstructorAny> = {
-    _id: $type<Ctor["__aggregateId"]>;
-} & $type<Ctor["__aggregateSchema"]>;
-export declare function aggregate<const Name extends string, Id extends ArcIdAny, SchemaShape extends ArcRawShape>(name: Name, id: Id, schema: SchemaShape): AggregateBuilder<Name, Id, ArcObject<SchemaShape>, [], [], []>;
-export {};
+import { ArcAggregateElement } from "./aggregate-element";
+export declare function aggregate<const Name extends string, Id extends ArcIdAny, SchemaShape extends ArcRawShape>(name: Name, id: Id, schema: SchemaShape): ArcAggregateElement<Name, Id, ArcObject<SchemaShape>, [], [], []>;
 //# sourceMappingURL=aggregate-builder.d.ts.map

package/dist/context-element/aggregate/aggregate-element.d.ts

@@ -1,69 +1,183 @@
 /**
- * ArcAggregateElement
+ * ArcAggregateElement — unified aggregate builder + context element.
  *
- * Implements ArcContextElement for an aggregate.
- * Created by aggregateContextElement(Constructor).
+ * aggregate() returns this directly. No .build() or aggregateContextElement() needed.
+ * Each builder method returns a new immutable instance.
  *
- * Looks like an ArcView to the rest of the system:
- * - queryContext() → find/findOne returning class instances
- * - mutateContext() → emit per registered event
- * - getHandlers() / getElements() → for eventPublisher.registerViews()
- * - databaseStoreSchema() → view table schema
+ * From the framework's perspective, behaves like a view:
+ * - queryContext() → named query methods
+ * - mutateContext() → named mutation methods
+ * - getHandlers() / getElements() → for eventPublisher registration
+ * - databaseStoreSchema() → table schema
  */
 import type { DatabaseStoreSchema } from "../../data-storage/database-store";
+import type { ArcIdAny } from "../../elements/id";
+import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../../elements/object";
 import type { ModelAdapters } from "../../model/model-adapters";
+import type { Simplify } from "../../utils";
+import type { $type } from "../../utils/types/get-type";
+import type { ArcTokenAny } from "../../token/token";
 import { ArcContextElement } from "../context-element";
-import type { ArcEventAny } from "../event/event";
-import type { AggregateConstructorAny } from "./aggregate-builder";
-import type { AggregateMutateMethodContext, AggregateQueryContext } from "./aggregate-data";
-/**
- * ArcAggregateElement — single context element for an aggregate.
- *
- * From the framework's perspective this behaves like a view:
- * - eventPublisher.registerViews() accepts it (duck typing via getHandlers/getElements/schema)
- * - queryContext provides find/findOne
- * - mutateContext provides emit per event
- */
-export declare class ArcAggregateElement<Ctor extends AggregateConstructorAny> extends ArcContextElement<Ctor["__aggregateName"]> {
-    private readonly ctor;
+import { ArcEvent, type ArcEventAny } from "../event/event";
+import type { ArcEventInstance } from "../event/instance";
+import type { ArcViewHandlerContext, ArcViewItem } from "../view/view-context";
+import type { ViewProtection, ViewProtectionFn } from "../view/view-data";
+import { AggregateBase } from "./aggregate-base";
+import type { AggregateCronMethodEntry, AggregateEventEntry, AggregateMutateMethodContext, AggregateMutateMethodEntry, AggregateQueryContext, AggregateQueryMethodEntry } from "./aggregate-data";
+type InlineArcEvent<EN extends string, PS extends ArcRawShape> = ArcEvent<{
+    name: EN;
+    payload: ArcObject<PS>;
+    protections: [];
+}>;
+export type AggregateRow<Id extends ArcIdAny, Schema extends ArcObjectAny> = Simplify<$type<Schema> & {
+    _id: $type<Id>;
+}>;
+type AggregatePrivateQuery<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    find: {
+        <M extends new (row: AggregateRow<Id, Schema>, adapters: any) => any>(options: any, mapper: M): Promise<InstanceType<M>[]>;
+        (options?: any): Promise<AggregateRow<Id, Schema>[]>;
+    };
+    findOne: {
+        <M extends new (row: AggregateRow<Id, Schema>, adapters: any) => any>(where: any, mapper: M): Promise<InstanceType<M> | undefined>;
+        (where?: any): Promise<AggregateRow<Id, Schema> | undefined>;
+    };
+};
+type MutateMethodContext<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
+    [E in Events[number] as E["event"]["name"]]: {
+        emit: (payload: E["event"]["payload"] extends {
+            deserialize: (...a: any) => any;
+        } ? $type<E["event"]["payload"]> : undefined) => Promise<void>;
+    };
+} & {
+    $auth: {
+        params: any;
+        tokenName: string;
+    };
+    $query: AggregatePrivateQuery<Id, Schema>;
+};
+type ClientQueryContext<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
+    $query: AggregatePrivateQuery<Id, Schema>;
+    $auth: {
+        params: any;
+        tokenName: string;
+    };
+    Aggregate: AggregateConstructor<Id, Schema, Events>;
+};
+export type AggregateInstanceCtx<Events extends AggregateEventEntry[]> = {
+    [E in Events[number] as E["event"]["name"]]: {
+        emit: (payload: E["event"]["payload"] extends {
+            deserialize: (...a: any) => any;
+        } ? $type<E["event"]["payload"]> : undefined) => Promise<void>;
+    };
+};
+type PublicEvents<Events extends AggregateEventEntry[]> = Extract<Events[number], {
+    isPublic: true;
+}>;
+type PublicEventNames<Events extends AggregateEventEntry[]> = PublicEvents<Events>["event"]["name"];
+type GetPublicEvent<Events extends AggregateEventEntry[], Name extends string> = Extract<PublicEvents<Events>, {
+    event: {
+        name: Name;
+    };
+}>["event"];
+export type AggregateConstructor<Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, Events extends AggregateEventEntry[] = AggregateEventEntry[]> = (new (row: ArcViewItem<Id, Schema>, adapters: ModelAdapters) => AggregateBase<Id, Schema, Events>) & {
+    readonly __aggregateName: string;
+    readonly __aggregateId: Id;
+    readonly __aggregateSchema: Schema;
+    readonly __aggregateEvents: Events;
+    readonly __aggregateProtections: ViewProtection[];
+    readonly __aggregateMutateMethods: AggregateMutateMethodEntry[];
+    readonly __aggregateQueryMethods: AggregateQueryMethodEntry[];
+    readonly __aggregateCronMethods: AggregateCronMethodEntry[];
+    getEvent<EventName extends PublicEventNames<Events>>(name: EventName): GetPublicEvent<Events, EventName>;
+};
+export type AggregateConstructorAny = AggregateConstructor<any, any, any>;
+/** Extract the full row type from an aggregate element. */
+export type AggregateData<El extends ArcAggregateElement<any, any, any, any, any>> = AggregateRow<El extends ArcAggregateElement<infer _N, infer I, any, any, any> ? I : never, El extends ArcAggregateElement<infer _N, any, infer S, any, any> ? S : never>;
+export declare class ArcAggregateElement<Name extends string = string, Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, Events extends AggregateEventEntry[] = AggregateEventEntry[], MutateMethods extends AggregateMutateMethodEntry[] = AggregateMutateMethodEntry[], QueryMethods extends AggregateQueryMethodEntry[] = AggregateQueryMethodEntry[]> extends ArcContextElement<Name> {
     /** Expose schema for eventPublisher view registration (duck typing) */
-    readonly schema: Ctor["__aggregateSchema"];
-    constructor(ctor: Ctor);
+    readonly schema: Schema;
+    private readonly _id_factory;
+    private readonly _events;
+    private readonly _protections;
+    private readonly _mutateMethods;
+    private readonly _queryMethods;
+    private _ctor?;
+    constructor(name: Name, idFactory: Id, schema: Schema, events?: Events, protections?: ViewProtection[], mutateMethods?: MutateMethods, queryMethods?: QueryMethods, seeds?: {
+        data: any[];
+        version: number;
+    });
+    protectBy<T extends ArcTokenAny>(token: T, protectionFn: ViewProtectionFn<any>): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
+    event<const EventName extends string, PayloadShape extends ArcRawShape>(eventName: EventName, payload: PayloadShape, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<InlineArcEvent<EventName, PayloadShape>>) => Promise<void>): ArcAggregateElement<Name, Id, Schema, [
+        ...Events,
+        AggregateEventEntry<InlineArcEvent<EventName, PayloadShape>, Id, Schema, false>
+    ], MutateMethods, QueryMethods>;
+    publicEvent<const EventName extends string, PayloadShape extends ArcRawShape>(eventName: EventName, payload: PayloadShape, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<InlineArcEvent<EventName, PayloadShape>>) => Promise<void>): ArcAggregateElement<Name, Id, Schema, [
+        ...Events,
+        AggregateEventEntry<InlineArcEvent<EventName, PayloadShape>, Id, Schema, true>
+    ], MutateMethods, QueryMethods>;
+    handleEvent<E extends ArcEventAny>(arcEvent: E, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<E>) => Promise<void>): ArcAggregateElement<Name, Id, Schema, [
+        ...Events,
+        AggregateEventEntry<E, ArcIdAny, ArcObjectAny, false>
+    ], MutateMethods, QueryMethods>;
+    mutateMethod<const MethodName extends string, ParamsShape extends ArcRawShape, HR = void, R = never>(methodName: MethodName, config: {
+        params: ParamsShape;
+        result?: R;
+    }, handler: ((ctx: MutateMethodContext<Id, Schema, Events>, params: $type<ArcObject<ParamsShape>>) => Promise<HR>) | false): ArcAggregateElement<Name, Id, Schema, Events, [
+        ...MutateMethods,
+        {
+            name: MethodName;
+            params: ArcObject<ParamsShape>;
+            handler: typeof handler;
+            handlerReturn: HR;
+            result: R;
+        }
+    ], QueryMethods>;
+    cron(expression: string): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
+    clientQuery<const MethodName extends string, H extends (ctx: ClientQueryContext<Id, Schema, Events>, ...args: any[]) => Promise<any>>(methodName: MethodName, handler: H): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, [
+        ...QueryMethods,
+        {
+            name: MethodName;
+            handler: H;
+        }
+    ]>;
     /**
-     * Returns event handlers keyed by event name.
-     * Same shape as ArcView.getHandlers().
+     * Declare seed data inserted after table creation.
+     * Rows with `_id` use it as-is; rows without get auto-generated IDs.
      */
-    getHandlers(): Record<string, (ctx: any, event: any) => Promise<void>>;
+    seedWith(data: Array<$type<Schema> & {
+        _id?: $type<Id>;
+    }>, options?: {
+        version?: number;
+    }): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
     /**
-     * Returns event elements this aggregate listens to.
-     * Same shape as ArcView.getElements().
+     * Return a copy with seed data attached.
+     * Use with context.replace() to add seeds to framework-provided aggregates.
      */
+    withSeeds(data: Array<$type<Schema> & {
+        _id?: $type<Id>;
+    }>, options?: {
+        version?: number;
+    }): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
+    /** The internal AggregateConstructor class. Use in clientQuery to extend with business methods. */
+    get Aggregate(): AggregateConstructor<Id, Schema, Events>;
+    private buildConstructor;
+    getHandlers(): Record<string, (ctx: any, event: any) => Promise<void>>;
     getElements(): ArcEventAny[];
-    /**
-     * queryContext — exposes declared queryMethod entries as callable functions.
-     *
-     * Each queryMethod handler receives { $query: { find, findOne }, $auth }
-     * where $query reads from the appropriate adapter (dataStorage, streamingCache, or queryWire).
-     * Returns aggregate class instances.
-     */
-    queryContext(adapters: ModelAdapters): AggregateQueryContext<Ctor["__aggregateQueryMethods"]>;
-    /**
-     * Build private query methods (find/findOne) that work across all adapter modes.
-     * Used internally by queryMethod handlers via ctx.$query.
-     */
+    /** Public event accessor (same as old static getEvent) */
+    getEvent<EventName extends PublicEventNames<Events>>(eventName: EventName): GetPublicEvent<Events, EventName>;
+    /** Cron methods for CronScheduler discovery */
+    get cronMethods(): AggregateCronMethodEntry[];
+    queryContext(adapters: ModelAdapters): AggregateQueryContext<QueryMethods>;
     private buildPrivateQuery;
+    private buildUnrestrictedQuery;
     private getAuth;
-    /**
-     * mutateContext — exposes declared mutateMethod entries as callable functions.
-     *
-     * Each mutateMethod becomes a named function: `(params) => Promise<any>`.
-     * The handler receives a context with emit per event + $auth + $query.
-     */
-    mutateContext(adapters: ModelAdapters): AggregateMutateMethodContext<Ctor["__aggregateMutateMethods"]>;
-    /**
-     * databaseStoreSchema — same as ArcView.
-     * Creates a table named after the aggregate with _id + schema fields.
-     */
+    mutateContext(adapters: ModelAdapters): AggregateMutateMethodContext<MutateMethods>;
     databaseStoreSchema(): DatabaseStoreSchema;
+    getSeeds(): {
+        idFactory: Id;
+        data: any[];
+        version: number;
+    } | undefined;
 }
+export {};
 //# sourceMappingURL=aggregate-element.d.ts.map

package/dist/context-element/aggregate/index.d.ts

@@ -2,30 +2,14 @@
  * Aggregate module
  *
  * Exports:
- * - aggregate() — builder entry point
- * - aggregateContextElement() — creates ArcContextElement from aggregate class
- * - AggregateBase — base class for instances
+ * - aggregate() — creates ArcAggregateElement directly (no .build() needed)
+ * - ArcAggregateElement — the unified builder + context element
+ * - AggregateBase — base class for instances (used internally and in clientQuery)
  * - Types
  */
-export { aggregate, AggregateBuilder } from "./aggregate-builder";
-export type { AggregateConstructor, AggregateConstructorAny, AggregateData, AggregateInstanceCtx, } from "./aggregate-builder";
+export { aggregate } from "./aggregate-builder";
+export { ArcAggregateElement, type AggregateConstructor, type AggregateConstructorAny, type AggregateData, type AggregateInstanceCtx, type AggregateRow, } from "./aggregate-element";
 export { AggregateBase } from "./aggregate-base";
-export { ArcAggregateElement } from "./aggregate-element";
 export type { AggregateCronMethodEntry, AggregateEventEntry, AggregateEventHandler, AggregateMutateMethodContext, AggregateMutateMethodEntry, AggregateQueryContext, AggregateQueryMethodEntry, AggregateStaticConfig, } from "./aggregate-data";
 export type { ArcEventPayload } from "../event/instance";
-import type { AggregateConstructorAny } from "./aggregate-builder";
-import { ArcAggregateElement } from "./aggregate-element";
-/**
- * Create an ArcContextElement from an aggregate class.
- *
- * @param ctor - Aggregate class (extends the result of aggregate().build())
- * @returns ArcAggregateElement ready for context([])
- *
- * @example
- * ```ts
- * const taskElement = aggregateContextElement(Task);
- * const appContext = context([taskElement]);
- * ```
- */
-export declare function aggregateContextElement<Ctor extends AggregateConstructorAny>(ctor: Ctor): ArcAggregateElement<Ctor>;
 //# sourceMappingURL=index.d.ts.map

package/dist/context-element/context-element.d.ts

@@ -69,6 +69,13 @@ export declare abstract class ArcContextElement<const Name extends string> exten
      * - Views: { findOne: (query) => Promise<data>, findMany: (query) => Promise<data[]> }
      */
     queryContext?(adapters: ModelAdapters): unknown;
+    protected _seeds?: {
+        data: any[];
+        version: number;
+        idFactory?: any;
+    };
+    /** Get seed data declared via seedWith() or withSeeds(). */
+    getSeeds(): typeof this._seeds;
 }
 /**
  * Type helper to extract element name from element type

package/dist/index.js

@@ -3,14 +3,23 @@ var TOKEN_PREFIX = "arc:token:";
 function hasLocalStorage() {
   return typeof localStorage !== "undefined";
 }
+function notifyTokenChange(scope) {
+  if (typeof window !== "undefined") {
+    queueMicrotask(() => {
+      window.dispatchEvent(new CustomEvent("arc:token-change", { detail: { scope } }));
+    });
+  }
+}
 
 class AuthAdapter {
   scopes = new Map;
   setToken(token, scope = "default") {
     if (!token) {
       this.scopes.delete(scope);
-      if (hasLocalStorage())
+      if (hasLocalStorage()) {
         localStorage.removeItem(TOKEN_PREFIX + scope);
+        notifyTokenChange(scope);
+      }
       return;
     }
     try {
@@ -31,8 +40,10 @@ class AuthAdapter {
           exp: payload.exp
         }
       });
-      if (hasLocalStorage())
+      if (hasLocalStorage()) {
         localStorage.setItem(TOKEN_PREFIX + scope, token);
+        notifyTokenChange(scope);
+      }
     } catch {
       this.scopes.delete(scope);
       if (hasLocalStorage())
@@ -714,6 +725,12 @@ class ArcContext {
   get(name) {
     return this.elementMap.get(name);
   }
+  replace(name, element) {
+    if (!this.elementMap.has(name))
+      throw new Error(`Context element "${name}" not found`);
+    const newElements = this.elements.map((el) => el.name === name ? element : el);
+    return new ArcContext(newElements);
+  }
 }
 function context(elements) {
   return new ArcContext(elements);
@@ -1266,42 +1283,6 @@ class ArcPrimitive extends ArcAbstract {
   }
 }
 
-// src/elements/boolean.ts
-class ArcBoolean extends ArcPrimitive {
-  hasToBeTrue() {
-    return this.validation("hasToBeTrue", (value) => {
-      if (!value)
-        return {
-          current: value
-        };
-    });
-  }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
-  }
-  toJsonSchema() {
-    const schema = { type: "boolean" };
-    if (this._description) {
-      schema.description = this._description;
-    }
-    return schema;
-  }
-  getColumnData() {
-    const storeData = this.getStoreData();
-    return {
-      type: "boolean",
-      storeData: {
-        ...storeData,
-        isNullable: false
-      }
-    };
-  }
-}
-function boolean() {
-  return new ArcBoolean;
-}
-
 // src/elements/string.ts
 var stringValidator = typeValidatorBuilder("string");
 
@@ -1455,6 +1436,66 @@ function string() {
   return new ArcString;
 }
 
+// src/fragment/arc-fragment.ts
+class ArcFragmentBase {
+  is(type) {
+    return this.types.includes(type);
+  }
+}
+
+// src/context-element/context-element.ts
+class ArcContextElement extends ArcFragmentBase {
+  name;
+  types = ["context-element"];
+  get id() {
+    return this.name;
+  }
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  _seeds;
+  getSeeds() {
+    return this._seeds;
+  }
+}
+
+// src/elements/boolean.ts
+class ArcBoolean extends ArcPrimitive {
+  hasToBeTrue() {
+    return this.validation("hasToBeTrue", (value) => {
+      if (!value)
+        return {
+          current: value
+        };
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  toJsonSchema() {
+    const schema = { type: "boolean" };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "boolean",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
+}
+function boolean() {
+  return new ArcBoolean;
+}
+
 // src/elements/id.ts
 class ArcCustomId extends ArcBranded {
   createFn;
@@ -1545,26 +1586,6 @@ function number() {
   return new ArcNumber;
 }
 
-// src/fragment/arc-fragment.ts
-class ArcFragmentBase {
-  is(type) {
-    return this.types.includes(type);
-  }
-}
-
-// src/context-element/context-element.ts
-class ArcContextElement extends ArcFragmentBase {
-  name;
-  types = ["context-element"];
-  get id() {
-    return this.name;
-  }
-  constructor(name) {
-    super();
-    this.name = name;
-  }
-}
-
 // src/context-element/event/event.ts
 class ArcEvent extends ArcContextElement {
   data;
@@ -1715,7 +1736,7 @@ class AggregateBase {
   }
 }
 
-// src/context-element/aggregate/aggregate-builder.ts
+// src/context-element/aggregate/aggregate-element.ts
 function createInlineEvent(eventName, payload) {
   const po = payload instanceof ArcObject ? payload : new ArcObject(payload);
   return new ArcEvent({
@@ -1725,25 +1746,27 @@ function createInlineEvent(eventName, payload) {
   });
 }
 
-class AggregateBuilder {
-  _name;
-  _id;
-  _schema;
+class ArcAggregateElement extends ArcContextElement {
+  schema;
+  _id_factory;
   _events;
   _protections;
   _mutateMethods;
   _queryMethods;
-  constructor(name, id2, schema, events = [], protections = [], mutateMethods = [], queryMethods = []) {
-    this._name = name;
-    this._id = id2;
-    this._schema = schema;
+  _ctor;
+  constructor(name, idFactory, schema, events = [], protections = [], mutateMethods = [], queryMethods = [], seeds) {
+    super(name);
+    this._id_factory = idFactory;
+    this.schema = schema;
     this._events = events;
     this._protections = protections;
     this._mutateMethods = mutateMethods;
     this._queryMethods = queryMethods;
+    if (seeds)
+      this._seeds = { ...seeds, idFactory };
   }
   protectBy(token, protectionFn) {
-    return new AggregateBuilder(this._name, this._id, this._schema, this._events, [...this._protections, { token, protectionFn }], this._mutateMethods, this._queryMethods);
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, [...this._protections, { token, protectionFn }], this._mutateMethods, this._queryMethods, this._seeds);
   }
   event(eventName, payload, handler) {
     const arcEvent = createInlineEvent(eventName, payload);
@@ -1753,7 +1776,7 @@ class AggregateBuilder {
       isInline: true,
       isPublic: false
     };
-    return new AggregateBuilder(this._name, this._id, this._schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods);
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods, this._seeds);
   }
   publicEvent(eventName, payload, handler) {
     const arcEvent = createInlineEvent(eventName, payload);
@@ -1763,7 +1786,7 @@ class AggregateBuilder {
       isInline: true,
       isPublic: true
     };
-    return new AggregateBuilder(this._name, this._id, this._schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods);
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods, this._seeds);
   }
   handleEvent(arcEvent, handler) {
     const entry = {
@@ -1772,7 +1795,7 @@ class AggregateBuilder {
       isInline: false,
       isPublic: false
     };
-    return new AggregateBuilder(this._name, this._id, this._schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods);
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods, this._seeds);
   }
   mutateMethod(methodName, config, handler) {
     const paramsObj = config.params instanceof ArcObject ? config.params : new ArcObject(config.params);
@@ -1781,28 +1804,39 @@ class AggregateBuilder {
       params: paramsObj,
       handler
     };
-    return new AggregateBuilder(this._name, this._id, this._schema, this._events, this._protections, [...this._mutateMethods, entry], this._queryMethods);
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, [...this._mutateMethods, entry], this._queryMethods, this._seeds);
   }
   cron(expression) {
     if (this._mutateMethods.length === 0) {
       throw new Error("cron() must be called immediately after mutateMethod()");
     }
     const methods = [...this._mutateMethods];
-    const lastIndex = methods.length - 1;
-    methods[lastIndex] = { ...methods[lastIndex], cronExpression: expression };
-    return new AggregateBuilder(this._name, this._id, this._schema, this._events, this._protections, methods, this._queryMethods);
+    methods[methods.length - 1] = { ...methods[methods.length - 1], cronExpression: expression };
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, methods, this._queryMethods, this._seeds);
   }
   clientQuery(methodName, handler) {
     const entry = {
       name: methodName,
       handler
     };
-    return new AggregateBuilder(this._name, this._id, this._schema, this._events, this._protections, this._mutateMethods, [...this._queryMethods, entry]);
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, this._mutateMethods, [...this._queryMethods, entry], this._seeds);
+  }
+  seedWith(data, options) {
+    return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, this._mutateMethods, this._queryMethods, { data, version: options?.version ?? 1 });
+  }
+  withSeeds(data, options) {
+    return this.seedWith(data, options);
+  }
+  get Aggregate() {
+    if (!this._ctor) {
+      this._ctor = this.buildConstructor();
+    }
+    return this._ctor;
   }
-  build() {
-    const name = this._name;
-    const id2 = this._id;
-    const schema = this._schema;
+  buildConstructor() {
+    const name = this.name;
+    const id2 = this._id_factory;
+    const schema = this.schema;
     const events = this._events;
     const protections = this._protections;
     const mutateMethods = this._mutateMethods;
@@ -1831,52 +1865,52 @@ class AggregateBuilder {
         return entry?.event;
       }
     };
-    Object.defineProperty(AggregateClass, "name", {
-      value: `${name}Aggregate`
-    });
+    Object.defineProperty(AggregateClass, "name", { value: `${name}Aggregate` });
     return AggregateClass;
   }
-}
-function aggregate(name, id2, schema) {
-  const schemaObj = schema instanceof ArcObject ? schema : new ArcObject(schema);
-  return new AggregateBuilder(name, id2, schemaObj, [], [], [], []);
-}
-// src/context-element/aggregate/aggregate-element.ts
-class ArcAggregateElement extends ArcContextElement {
-  ctor;
-  schema;
-  constructor(ctor) {
-    super(ctor.__aggregateName);
-    this.ctor = ctor;
-    this.schema = ctor.__aggregateSchema;
-  }
   getHandlers() {
     const handlers = {};
-    for (const entry of this.ctor.__aggregateEvents) {
+    for (const entry of this._events) {
       handlers[entry.event.name] = entry.handler;
     }
     return handlers;
   }
   getElements() {
-    return this.ctor.__aggregateEvents.map((e) => e.event);
+    return this._events.map((e) => e.event);
+  }
+  getEvent(eventName) {
+    const entry = this._events.find((e) => e.isPublic && e.event.name === eventName);
+    return entry?.event;
+  }
+  get cronMethods() {
+    const result = [];
+    for (const method of this._mutateMethods) {
+      if (method.cronExpression) {
+        result.push({
+          aggregateName: this.name,
+          methodName: method.name,
+          cronExpression: method.cronExpression
+        });
+      }
+    }
+    return result;
   }
   queryContext(adapters) {
     const privateQuery = this.buildPrivateQuery(adapters);
-    const queryMethods = this.ctor.__aggregateQueryMethods ?? [];
     const auth = this.getAuth(adapters);
+    const AggCtor = this.Aggregate;
     const result = {};
-    for (const method of queryMethods) {
+    for (const method of this._queryMethods) {
       result[method.name] = (...args) => {
-        const ctx = { $query: privateQuery, $auth: auth };
+        const ctx = { $query: privateQuery, $auth: auth, Aggregate: AggCtor };
         return method.handler(ctx, ...args);
       };
     }
     return result;
   }
   buildPrivateQuery(adapters) {
-    const viewName = this.ctor.__aggregateName;
-    const protections = this.ctor.__aggregateProtections;
-    const Ctor = this.ctor;
+    const viewName = this.name;
+    const protections = this._protections;
     const getReadRestrictions = () => {
       if (protections.length === 0)
         return null;
@@ -1906,18 +1940,15 @@ class ArcAggregateElement extends ArcContextElement {
       return { ...options, where };
     };
     const findRows = async (options) => {
-      if (adapters.dataStorage) {
+      if (adapters.dataStorage)
         return adapters.dataStorage.getStore(viewName).find(options);
-      }
-      if (adapters.streamingCache) {
+      if (adapters.streamingCache)
         return adapters.streamingCache.getStore(viewName).find(options);
-      }
-      if (adapters.queryWire) {
+      if (adapters.queryWire)
         return adapters.queryWire.query(viewName, options);
-      }
       return [];
     };
-    const schema = this.ctor.__aggregateSchema;
+    const schema = this.schema;
     const deserializeRow = (row) => {
       const { _id, ...rest } = row;
       return { _id, ...schema.deserialize(rest) };
@@ -1943,6 +1974,36 @@ class ArcAggregateElement extends ArcContextElement {
       }
     };
   }
+  buildUnrestrictedQuery(adapters) {
+    const viewName = this.name;
+    const schema = this.schema;
+    const deserializeRow = (row) => {
+      const { _id, ...rest } = row;
+      return { _id, ...schema.deserialize(rest) };
+    };
+    const findRows = async (options) => {
+      if (adapters.dataStorage)
+        return adapters.dataStorage.getStore(viewName).find(options);
+      if (adapters.streamingCache)
+        return adapters.streamingCache.getStore(viewName).find(options);
+      if (adapters.queryWire)
+        return adapters.queryWire.query(viewName, options);
+      return [];
+    };
+    return {
+      find: async (options, mapper) => {
+        const rows = await findRows(options || {});
+        return mapper ? rows.map((row) => new mapper(row, adapters)) : rows.map(deserializeRow);
+      },
+      findOne: async (where, mapper) => {
+        const rows = await findRows({ where });
+        const row = rows[0];
+        if (!row)
+          return;
+        return mapper ? new mapper(row, adapters) : deserializeRow(row);
+      }
+    };
+  }
   getAuth(adapters) {
     if (adapters.authAdapter) {
       const decoded = adapters.authAdapter.getDecoded();
@@ -1951,9 +2012,10 @@ class ArcAggregateElement extends ArcContextElement {
     return { params: {}, tokenName: "" };
   }
   mutateContext(adapters) {
-    const events = this.ctor.__aggregateEvents;
-    const privateQuery = this.buildPrivateQuery(adapters);
+    const events = this._events;
+    const privateQuery = this.buildUnrestrictedQuery(adapters);
     const auth = this.getAuth(adapters);
+    const aggregateName = this.name;
     const buildMutateMethodCtx = () => {
       const ctx = {};
       for (const entry of events) {
@@ -1978,14 +2040,14 @@ class ArcAggregateElement extends ArcContextElement {
       return ctx;
     };
     const result = {};
-    for (const method of this.ctor.__aggregateMutateMethods ?? []) {
+    for (const method of this._mutateMethods) {
       result[method.name] = async (params) => {
         if (!method.handler) {
           if (!adapters.commandWire) {
             throw new Error(`Method "${method.name}" is server-only but no commandWire (WebSocket) is available.`);
           }
           const wireAuth = adapters.scope ? { scope: adapters.scope.scopeName, token: adapters.scope.getToken() } : undefined;
-          return adapters.commandWire.executeCommand(`${this.ctor.__aggregateName}.${method.name}`, params, wireAuth);
+          return adapters.commandWire.executeCommand(`${aggregateName}.${method.name}`, params, wireAuth);
         }
         const ctx = buildMutateMethodCtx();
         return method.handler(ctx, params);
@@ -1994,26 +2056,27 @@ class ArcAggregateElement extends ArcContextElement {
     return result;
   }
   databaseStoreSchema() {
-    const viewName = this.ctor.__aggregateName;
-    const idSchema = new ArcObject({
-      _id: new ArcString().primaryKey()
-    });
-    const viewSchema = idSchema.merge(this.ctor.__aggregateSchema.rawShape || {});
+    const idSchema = new ArcObject({ _id: new ArcString().primaryKey() });
+    const viewSchema = idSchema.merge(this.schema.rawShape || {});
     const eventSchema = ArcEvent.sharedDatabaseStoreSchema();
     return {
       tables: [
-        {
-          name: viewName,
-          schema: viewSchema
-        },
+        { name: this.name, schema: viewSchema },
         ...eventSchema.tables
       ]
     };
   }
+  getSeeds() {
+    if (!this._seeds)
+      return;
+    return { ...this._seeds, idFactory: this._id_factory };
+  }
 }
-// src/context-element/aggregate/index.ts
-function aggregateContextElement(ctor) {
-  return new ArcAggregateElement(ctor);
+
+// src/context-element/aggregate/aggregate-builder.ts
+function aggregate(name, id2, schema) {
+  const schemaObj = schema instanceof ArcObject ? schema : new ArcObject(schema);
+  return new ArcAggregateElement(name, id2, schemaObj);
 }
 // src/context-element/element-context.ts
 function buildElementContext(queryElements, mutationElements, adapters) {
@@ -4967,7 +5030,6 @@ export {
   array,
   applyOrderByAndLimit,
   any,
-  aggregateContextElement,
   aggregate,
   Wire,
   TokenInstance,
@@ -5019,6 +5081,5 @@ export {
   ArcAny,
   ArcAggregateElement,
   ArcAbstract,
-  AggregateBuilder,
   AggregateBase
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",