bleam 0.0.10 → 0.0.12

package/dist/state.cjs

@@ -1,19 +1,23 @@
 require('./native-runtime-CsXnXkQn.cjs');
 require('./crypto-CT3VZ7lF.cjs');
-const require_state = require('./state-Bx0VlTlO.cjs');
-require('./schema-rQ13mrpD.cjs');
+const require_schema = require('./schema-BnVZOXfu.cjs');
+const require_state = require('./state-LssDgpff.cjs');
 
-exports.Collection = require_state.Collection;
-exports.LiveStore = require_state.LiveStore;
+exports.CollectionVersionConflictError = require_state.CollectionVersionConflictError;
+exports.array = require_schema.array;
 exports.atom = require_state.atom;
-exports.collection = require_state.collection;
-exports.isLinked = require_state.isLinked;
-exports.link = require_state.link;
-exports.setting = require_state.setting;
-exports.unlink = require_state.unlink;
+exports.atomCollection = require_state.atomCollection;
+exports.boolean = require_schema.boolean;
+exports.literal = require_schema.literal;
+exports.mutateAtom = require_state.mutateAtom;
+exports.number = require_schema.number;
+exports.object = require_schema.object;
+exports.queryAtom = require_state.queryAtom;
+exports.string = require_schema.string;
+exports.transactionAtom = require_state.transactionAtom;
 exports.useAtom = require_state.useAtom;
+exports.useAtomValue = require_state.useAtomValue;
 exports.useField = require_state.useField;
 exports.useList = require_state.useList;
-exports.useSetting = require_state.useSetting;
-exports.useStore = require_state.useStore;
-exports.useView = require_state.useView;
+exports.useRow = require_state.useRow;
+exports.useSetAtom = require_state.useSetAtom;

package/dist/state.d.cts

@@ -1,159 +1,163 @@
-import { a as FieldValue, f as SchemaOutput, l as SchemaInput, m as SchemaShape, t as BleamSchema } from "./schema-ENSMX_1t.cjs";
+import { A as array, C as SchemaOutput, E as SchemaShape, F as number, I as object, P as literal, R as string, _ as ObjectField, b as SchemaInput, c as FieldPath, j as boolean, k as ValueAtFieldPath, s as FieldOutput, w as SchemaPatch } from "./schema-D5eImHxu.cjs";
 
 //#region src/state/atom.d.ts
-type Listener = () => void;
-interface Store<Value> {
-  get(): Value;
-  subscribe(listener: Listener): () => void;
+declare const atomValue: unique symbol;
+declare const atomWrite: unique symbol;
+interface Atom<Value> {
+  readonly [atomValue]: Value;
 }
-interface WritableStore<Value> extends Store<Value> {
-  set(value: Value): void;
-  update(updater: (value: Value) => Value): void;
-}
-declare class LiveStore<Value> implements WritableStore<Value> {
-  private value;
-  private listeners;
-  constructor(value: Value);
-  get(): Value;
-  set(value: Value): void;
-  update(updater: (value: Value) => Value): void;
-  subscribe(listener: Listener): () => void;
+interface WritableAtom<Value, Args$1 extends unknown[], Result$1> extends Atom<Value> {
+  readonly [atomWrite]: {
+    args: Args$1;
+    result: Result$1;
+  };
 }
-type Atom<Value> = WritableStore<Value>;
-type SetStoreValue<Value> = (value: Value | ((current: Value) => Value)) => void;
-declare function atom<Value>(initialValue: Value): Atom<Value>;
-declare function useStore<Value>(store: Store<Value>): Value;
-declare function useAtom<Value>(value: Atom<Value>): readonly [Value, SetStoreValue<Value>];
+type SetStateAction<Value> = Value | ((current: Value) => Value);
+type PrimitiveAtom<Value> = WritableAtom<Value, [SetStateAction<Value>], void>;
+type Getter = <Value>(value: Atom<Value>) => Value;
+type Setter = <Value, Args$1 extends unknown[], Result$1>(value: WritableAtom<Value, Args$1, Result$1>, ...args: Args$1) => Result$1;
+type AtomOptions = {
+  storage?: string;
+};
+declare function atom<Value, Args$1 extends unknown[], Result$1>(read: (get: Getter) => Value, write: (get: Getter, set: Setter, ...args: Args$1) => Result$1): WritableAtom<Value, Args$1, Result$1>;
+declare function atom<Value>(read: (get: Getter) => Value): Atom<Value>;
+declare function atom<Value>(initialValue: Value, options?: AtomOptions): PrimitiveAtom<Value>;
+declare function useAtomValue<Value>(value: Atom<Value>): Awaited<Value>;
+declare function useSetAtom<Value, Args$1 extends unknown[], Result$1>(value: WritableAtom<Value, Args$1, Result$1>): (...args: Args$1) => Result$1;
+declare function useAtom<Value, Args$1 extends unknown[], Result$1>(value: WritableAtom<Value, Args$1, Result$1>): [Awaited<Value>, (...args: Args$1) => Result$1];
 //#endregion
 //#region src/state/collection.d.ts
-type FieldRecord = Record<string, FieldValue | undefined>;
-type CollectionFields<Shape extends SchemaShape> = SchemaOutput<Shape>;
-type CollectionInput<Shape extends SchemaShape> = SchemaInput<Shape>;
-type CollectionData<Shape extends SchemaShape> = CollectionFields<Shape>;
-type CollectionFieldKey<Shape extends SchemaShape> = Extract<keyof Shape, string>;
-type CollectionFieldValue<Shape extends SchemaShape, Key extends CollectionFieldKey<Shape>> = Key extends keyof CollectionData<Shape> ? CollectionData<Shape>[Key] : undefined;
-type Entry<Value> = {
-  value: Value | undefined;
-  error: unknown;
-  promise: Promise<unknown> | null;
-  version: number;
-  listeners: Set<Listener>;
-};
-type RawCollectionView = {
-  id: string;
-  collection: string;
-  createdAt: string;
-  updatedAt: string;
-  data: FieldRecord;
-  links: Record<string, string[]>;
-};
-type RecordEntry = Entry<RawCollectionView | null>;
-type ListEntry = Entry<string[]> & {
-  dependencies: ListDependencies;
-};
-type CollectionReference = {
-  readonly name: string;
-  get(id: string): Promise<unknown>;
+declare const collectionBrand: unique symbol;
+type AnyShape = SchemaShape;
+type AnyCollection = CollectionAtom<AnyShape>;
+type Scalar = string | number | boolean;
+type MaybePromise<Value> = Value | Promise<Value>;
+type Order = 'asc' | 'desc';
+type Comparison = 'equals' | 'greater-than' | 'less-than' | 'contains';
+type ComparisonFor<Value> = Value extends number ? Exclude<Comparison, 'contains'> : Value extends string ? 'equals' | 'contains' : 'equals';
+type WhereClauseValue<Value> = Value | readonly [ComparisonFor<Value>, Value] | ReadonlyArray<readonly [ComparisonFor<Value>, Value]>;
+type ScalarFieldPath<Shape extends SchemaShape> = { [Key in Extract<keyof Shape, string>]: Shape[Key] extends {
+  kind: 'object';
+  shape: infer Nested extends SchemaShape;
+} ? `${Key}.${ScalarFieldPath<Nested>}` : Shape[Key] extends {
+  kind: 'array';
+} ? never : Key }[Extract<keyof Shape, string>];
+type ScalarAtPath<Shape extends SchemaShape, Path$1 extends ScalarFieldPath<Shape>> = Path$1 extends `${infer Key}.${infer Rest}` ? Key extends keyof Shape ? Shape[Key] extends ObjectField<infer Nested> ? Rest extends ScalarFieldPath<Nested> ? ScalarAtPath<Nested, Rest> : never : never : never : Path$1 extends keyof Shape ? Extract<FieldOutput<Shape[Path$1]>, Scalar> : never;
+type CollectionRow<Shape extends SchemaShape> = {
+  readonly id: string;
+  readonly collection: string;
+  readonly version: number;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly data: SchemaOutput<Shape>;
+  readonly links: Readonly<Record<string, readonly string[]>>;
 };
-type ViewOptions = {
-  links?: CollectionReference[];
+interface CollectionAtom<Shape extends SchemaShape> extends Atom<Promise<readonly string[]>> {
+  readonly [collectionBrand]: Shape;
+}
+declare class CollectionVersionConflictError extends Error {
+  readonly collection: string;
+  readonly id: string;
+  readonly expectedVersion: number;
+  readonly actualVersion: number;
+  readonly name = "CollectionVersionConflictError";
+  constructor(collection: string, id: string, expectedVersion: number, actualVersion: number);
+}
+type UpdateOptions = {
+  ifVersion?: number;
 };
-type ListWhereValue = FieldValue | ['equals' | 'greater-than' | 'less-than' | 'contains', FieldValue] | Array<['equals' | 'greater-than' | 'less-than' | 'contains', FieldValue]>;
-type ListOptions<Shape extends SchemaShape> = {
-  where?: Partial<Record<CollectionFieldKey<Shape>, ListWhereValue>>;
-  sortBy?: CollectionFieldKey<Shape> | 'createdAt' | 'updatedAt';
-  order?: 'asc' | 'desc';
-  take?: number;
+type RowOptions = {
+  links?: readonly AnyCollection[];
 };
-type NormalizedListOptions = {
-  where?: Record<string, Array<[string, FieldValue]>>;
-  sortBy?: string;
-  order?: 'asc' | 'desc';
-  take?: number;
+type CollectionWhere<Shape extends SchemaShape> = Partial<{ [Path in ScalarFieldPath<Shape>]: WhereClauseValue<ScalarAtPath<Shape, Path>> }>;
+type WhereClause = {
+  path: string;
+  comparison: Comparison;
+  operand: Scalar;
 };
-type RecordChange = {
-  collection: string;
-  id: string;
-  previous: RawCollectionView | null;
-  next: RawCollectionView | null;
-  changedPaths: Set<string>;
-};
-type EdgeChange = {
-  type: 'link' | 'unlink';
-  left: {
+type QueryPlan = {
+  terminal: 'ids' | 'row' | 'field';
+  where: WhereClause[];
+  from?: {
     collection: string;
     id: string;
   };
-  right: {
-    collection: string;
-    id: string;
+  sort?: {
+    path: string;
+    order: Order;
   };
+  take?: number;
+  id?: string;
+  path?: string;
+  links?: string[];
 };
-type ListDependencies = {
-  collection: string;
-  paths: Set<string>;
-  options: NormalizedListOptions;
+type QueryTerminal<Shape extends SchemaShape, Result$1> = {
+  readonly plan: QueryPlan;
+  readonly result?: Result$1;
+  readonly shape?: Shape;
 };
-type CollectionView<Shape extends SchemaShape> = {
-  readonly id: string;
-  readonly collection: string;
-  readonly createdAt: string;
-  readonly updatedAt: string;
-  readonly data: CollectionData<Shape>;
-  readonly links: Record<string, string[]>;
+interface QueryBuilder<Shape extends SchemaShape> {
+  where(filters: CollectionWhere<Shape>): QueryBuilder<Shape>;
+  from<OtherShape extends SchemaShape>(other: CollectionAtom<OtherShape>, id: string): QueryBuilder<Shape>;
+  sortBy(path: ScalarFieldPath<Shape> | 'createdAt' | 'updatedAt', order?: Order): QueryBuilder<Shape>;
+  take(count: number): QueryBuilder<Shape>;
+  ids(): QueryTerminal<Shape, readonly string[]>;
+  row(id: string, options?: RowOptions): QueryTerminal<Shape, CollectionRow<Shape> | null>;
+  field<Path$1 extends FieldPath<Shape>>(id: string, path: Path$1): QueryTerminal<Shape, ValueAtFieldPath<Shape, Path$1> | undefined>;
+}
+type InsertTerminal<Shape extends SchemaShape> = {
+  kind: 'insert';
+  args: [SchemaInput<Shape>];
+  result: string;
 };
-declare class Collection<Shape extends SchemaShape> {
-  readonly name: string;
-  readonly shape: Shape;
-  readonly validator: BleamSchema<SchemaInput<Shape>, SchemaOutput<Shape>>;
-  private records;
-  private lists;
-  private fields;
-  constructor(name: string, shape: Shape);
-  validateListOptions(options?: ListOptions<Shape>): void;
-  getRecordEntry(id: string): RecordEntry;
-  getListEntry(options?: ListOptions<Shape>): ListEntry;
-  private getFieldEntry;
-  private notifyFields;
-  private setRecordValue;
-  private rawRecord;
-  private loadRecord;
-  private loadListRows;
-  private selectListRows;
-  private applyListOptions;
-  private refreshListEntry;
-  invalidateChanges(recordChanges: RecordChange[], edgeChanges?: EdgeChange[]): Promise<void>;
-  private refreshLoadedLinks;
-  private peekRecord;
-  insert(value: CollectionInput<Shape>): Promise<string>;
-  update(id: string, value: Partial<CollectionInput<Shape>>): Promise<void>;
-  delete(id: string): Promise<void>;
-  all(): Promise<CollectionView<Shape>[]>;
-  get(id: string): Promise<CollectionView<Shape> | null>;
-  subscribeRecord(id: string, listener: Listener): () => void;
-  subscribeList(options: ListOptions<Shape> | undefined, listener: Listener): () => void;
-  subscribeField(id: string, path: string, listener: Listener): () => void;
-  getRecordVersion(id: string): number;
-  getListVersion(options?: ListOptions<Shape>): number;
-  getFieldVersion(id: string, path: string): number;
-  getRecordSnapshot(id: string, options?: ViewOptions): CollectionView<Shape> | null | undefined;
-  getListSnapshot(options?: ListOptions<Shape>): string[] | undefined;
-  ensureRecord(id: string, options?: ViewOptions): Promise<RawCollectionView | null>;
-  ensureList(options?: ListOptions<Shape>): Promise<string[]>;
-  private deleteLinksForRecord;
+type UpdateTerminal<Shape extends SchemaShape> = {
+  kind: 'update';
+  id: string;
+  args: [SchemaPatch<Shape>, UpdateOptions?];
+  result: CollectionRow<Shape>;
+};
+type RemoveTerminal = {
+  kind: 'remove';
+  id: string;
+  args: [];
+  result: boolean;
+};
+type LinkTerminal = {
+  kind: 'link' | 'unlink';
+  id: string;
+  other: AnyCollection;
+  args: [string];
+  result: boolean;
+};
+type MutationTerminal<Shape extends SchemaShape> = InsertTerminal<Shape> | UpdateTerminal<Shape> | RemoveTerminal | LinkTerminal;
+interface MutationBuilder<Shape extends SchemaShape> {
+  insert(): InsertTerminal<Shape>;
+  update(id: string): UpdateTerminal<Shape>;
+  remove(id: string): RemoveTerminal;
+  link<OtherShape extends SchemaShape>(id: string, other: CollectionAtom<OtherShape>): LinkTerminal;
+  unlink<OtherShape extends SchemaShape>(id: string, other: CollectionAtom<OtherShape>): LinkTerminal;
 }
-declare function collection<Shape extends SchemaShape>(name: string, shape: Shape): Collection<Shape>;
-declare function link<FirstShape extends SchemaShape, SecondShape extends SchemaShape>(firstCollection: Collection<FirstShape>, firstId: string, secondCollection: Collection<SecondShape>, secondId: string): Promise<void>;
-declare function unlink<FirstShape extends SchemaShape, SecondShape extends SchemaShape>(firstCollection: Collection<FirstShape>, firstId: string, secondCollection: Collection<SecondShape>, secondId: string): Promise<void>;
-declare function isLinked<FirstShape extends SchemaShape, SecondShape extends SchemaShape>(firstCollection: Collection<FirstShape>, firstId: string, secondCollection: Collection<SecondShape>, secondId: string): Promise<boolean>;
-declare function useList<Shape extends SchemaShape>(collection: Collection<Shape>, options?: ListOptions<Shape>): string[];
-declare function useView<Shape extends SchemaShape>(collection: Collection<Shape>, id: string, options?: ViewOptions): CollectionView<Shape> | null | undefined;
-declare function useField<Shape extends SchemaShape, Key extends CollectionFieldKey<Shape>>(collection: Collection<Shape>, id: string, key: Key): CollectionFieldValue<Shape, Key> | undefined;
-//#endregion
-//#region src/state/setting.d.ts
-type Setting<Value> = WritableStore<Value>;
-type SetSettingValue<Value> = SetStoreValue<Value>;
-declare function setting<Value extends string | number | boolean>(key: string, initialValue: Value): Setting<Value>;
-declare function useSetting<Value>(value: Setting<Value>): readonly [Value, SetStoreValue<Value>];
+type TerminalArgs<Terminal> = Terminal extends {
+  args: infer Args extends unknown[];
+} ? Args : never;
+type TerminalResult<Terminal> = Terminal extends {
+  result: infer Result;
+} ? Result : never;
+declare function atomCollection<const Shape extends SchemaShape>(name: string, shape: Shape): CollectionAtom<Shape>;
+declare function queryAtom<Shape extends SchemaShape, Result$1>(collection: CollectionAtom<Shape>, build: (builder: QueryBuilder<Shape>) => QueryTerminal<Shape, Result$1>): Atom<Promise<Result$1>>;
+declare function mutateAtom<Shape extends SchemaShape, Terminal extends MutationTerminal<Shape>>(collection: CollectionAtom<Shape>, build: (builder: MutationBuilder<Shape>) => Terminal): WritableAtom<null, TerminalArgs<Terminal>, Promise<TerminalResult<Terminal>>>;
+interface TransactionContext {
+  get<Shape extends SchemaShape>(collection: CollectionAtom<Shape>, id: string, options?: RowOptions): Promise<CollectionRow<Shape> | null>;
+  query<Shape extends SchemaShape, Result$1>(collection: CollectionAtom<Shape>, build: (builder: QueryBuilder<Shape>) => QueryTerminal<Shape, Result$1>): Promise<Result$1>;
+  insert<Shape extends SchemaShape>(collection: CollectionAtom<Shape>, value: SchemaInput<Shape>): Promise<string>;
+  update<Shape extends SchemaShape>(collection: CollectionAtom<Shape>, id: string, patch: SchemaPatch<Shape>, options?: UpdateOptions): Promise<CollectionRow<Shape>>;
+  remove<Shape extends SchemaShape>(collection: CollectionAtom<Shape>, id: string): Promise<boolean>;
+  link<LeftShape extends SchemaShape, RightShape extends SchemaShape>(collection: CollectionAtom<LeftShape>, id: string, other: CollectionAtom<RightShape>, otherId: string): Promise<boolean>;
+  unlink<LeftShape extends SchemaShape, RightShape extends SchemaShape>(collection: CollectionAtom<LeftShape>, id: string, other: CollectionAtom<RightShape>, otherId: string): Promise<boolean>;
+}
+declare function transactionAtom<Args$1 extends unknown[], Result$1>(action: (context: TransactionContext, ...args: Args$1) => MaybePromise<Result$1>): WritableAtom<null, Args$1, Promise<Result$1>>;
+declare function useList<Shape extends SchemaShape>(collection: CollectionAtom<Shape>, build?: (builder: QueryBuilder<Shape>) => QueryTerminal<Shape, readonly string[]>): readonly string[];
+declare function useRow<Shape extends SchemaShape>(collection: CollectionAtom<Shape>, id: string, options?: RowOptions): CollectionRow<Shape> | null;
+declare function useField<Shape extends SchemaShape, Path$1 extends FieldPath<Shape>>(collection: CollectionAtom<Shape>, id: string, path: Path$1): ValueAtFieldPath<Shape, Path$1> | undefined;
 //#endregion
-export { Atom, Collection, CollectionView, ListOptions, Listener, LiveStore, SetSettingValue, SetStoreValue, Setting, Store, WritableStore, atom, collection, isLinked, link, setting, unlink, useAtom, useField, useList, useSetting, useStore, useView };
+export { type Atom, type AtomOptions, CollectionAtom, CollectionRow, CollectionVersionConflictError, CollectionWhere, type Getter, MutationBuilder, type PrimitiveAtom, QueryBuilder, RowOptions, type SetStateAction, type Setter, TransactionContext, UpdateOptions, type WritableAtom, array, atom, atomCollection, boolean, literal, mutateAtom, number, object, queryAtom, string, transactionAtom, useAtom, useAtomValue, useField, useList, useRow, useSetAtom };