@verdant-web/common 2.3.0-next.0 → 2.3.1

package/dist/esm/operation.d.ts

@@ -0,0 +1,142 @@
+import { DocumentBaseline } from './baseline.js';
+import { FileRef } from './files.js';
+import { ObjectIdentifier } from './oids.js';
+export type ObjectRef = {
+    '@@type': 'ref';
+    id: ObjectIdentifier;
+};
+export declare function isObjectRef(obj: any): obj is ObjectRef;
+export type Normalized<T> = {
+    [key in keyof T]: T[key] extends Object ? ObjectRef : T[key];
+};
+export type PropertyName = string | number;
+/**
+ * List patches can target a particular child list or
+ * nested lists. The first path item is the property path
+ * of the first child list, any subsequent values are nested
+ * list indices.
+ */
+export type PropertyValue = string | number | boolean | null | undefined | ObjectRef | FileRef;
+interface BaseOperationPatch {
+}
+export interface OperationPatchInitialize extends BaseOperationPatch {
+    op: 'initialize';
+    value: any;
+}
+export interface OperationPatchSet extends BaseOperationPatch {
+    op: 'set';
+    name: PropertyName;
+    value: PropertyValue;
+}
+export interface OperationPatchRemove extends BaseOperationPatch {
+    op: 'remove';
+    name: PropertyName;
+}
+export interface OperationPatchListPush extends BaseOperationPatch {
+    op: 'list-push';
+    value: PropertyValue;
+}
+export interface OperationPatchListInsert extends BaseOperationPatch {
+    op: 'list-insert';
+    index: number;
+    value?: PropertyValue;
+    values?: PropertyValue[];
+}
+export interface OperationPatchListDelete extends BaseOperationPatch {
+    op: 'list-delete';
+    index: number;
+    count: number;
+}
+/**
+ * Optimal for lists of object references. Moves
+ * the selected item to the target index even if it
+ * is not at the original index anymore.
+ */
+export interface OperationPatchListMoveByRef extends BaseOperationPatch {
+    op: 'list-move-by-ref';
+    value: ObjectRef | FileRef;
+    index: number;
+}
+/**
+ * Suitable for any list move, whether object lists
+ * or primitive lists.
+ */
+export interface OperationPatchListMoveByIndex extends BaseOperationPatch {
+    op: 'list-move-by-index';
+    from: number;
+    to: number;
+}
+/**
+ * Removes all instances of the value from
+ * the list. Good for set behavior or removing
+ * a specific item even if it changes index
+ * from conflicts.
+ */
+export interface OperationPatchListRemove extends BaseOperationPatch {
+    op: 'list-remove';
+    value: PropertyValue;
+    only?: 'first' | 'last';
+}
+export interface OperationPatchListAdd extends BaseOperationPatch {
+    op: 'list-add';
+    value: PropertyValue;
+}
+export interface OperationPatchDelete extends BaseOperationPatch {
+    op: 'delete';
+}
+export interface OperationPatchTouch extends BaseOperationPatch {
+    op: 'touch';
+}
+export type OperationPatch = OperationPatchInitialize | OperationPatchSet | OperationPatchRemove | OperationPatchListPush | OperationPatchListInsert | OperationPatchListDelete | OperationPatchListMoveByRef | OperationPatchListMoveByIndex | OperationPatchListRemove | OperationPatchDelete | OperationPatchListAdd | OperationPatchTouch;
+export type Operation = {
+    oid: ObjectIdentifier;
+    timestamp: string;
+    data: OperationPatch;
+};
+export declare function diffToPatches<T extends {
+    [key: string]: any;
+} | any[]>(from: T, to: T, getNow: () => string, createSubId?: () => string, patches?: Operation[], options?: {
+    /**
+     * If an object is merged with another and the new one does not
+     * have an OID assigned, assume it is the same identity as previous
+     */
+    mergeUnknownObjects?: boolean;
+    /**
+     * If an incoming value is not assigned on the new object, use the previous value.
+     * If false, undefined properties will erase the previous value.
+     */
+    defaultUndefined?: boolean;
+}): Operation[];
+export declare function shallowDiffToPatches(from: any, to: any, getNow: () => string, patches?: Operation[]): Operation[];
+/**
+ * Takes a basic object and constructs a patch list to create it and
+ * all of its nested objects.
+ */
+export declare function initialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, createSubId?: () => string, patches?: Operation[]): Operation[];
+export declare function shallowInitialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, patches?: Operation[]): Operation[];
+export declare function groupPatchesByOid(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupPatchesByRootOid(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupBaselinesByRootOid(baselines: DocumentBaseline[]): Record<string, DocumentBaseline[]>;
+export type NormalizedObject = {
+    [key: PropertyName]: PropertyValue;
+} | Array<PropertyValue>;
+/**
+ * The incoming object should already be normalized!
+ * This function will mutate the base object.
+ */
+export declare function applyPatch<T extends NormalizedObject>(base: T | undefined, patch: OperationPatch, 
+/**
+ * Optionally supply a list to which any refs which
+ * are removed during the patch will be appended.
+ */
+deletedRefs?: (FileRef | ObjectRef)[]): T | undefined;
+export declare function applyOperations<T extends NormalizedObject>(base: T | undefined, operations: Operation[], deletedRefs?: (ObjectRef | FileRef)[]): T | undefined;
+/**
+ * Mutates the original object in place. Returns all referenced
+ * objects oids.
+ */
+export declare function substituteRefsWithObjects(base: any, refs: Map<ObjectIdentifier, any>, used?: ObjectIdentifier[]): ObjectIdentifier[];
+export declare function substituteFirstLevelObjectsWithRefs<Base extends {
+    [key: string]: any;
+} | any[]>(base: Base, refObjects?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+export {};

package/dist/esm/operation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/patch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * High-level patch creation for use with complex nested objects.
+ */
+import { FileRef } from './files.js';
+import { ObjectIdentifier } from './oids.js';
+import { ObjectRef, Operation, PropertyName } from './operation.js';
+export declare class PatchCreator {
+    private getNow;
+    private createSubId?;
+    constructor(getNow: () => string, createSubId?: (() => string) | undefined);
+    isPrimitive: (value: any) => boolean;
+    createDiff: (from: any, to: any, options?: {
+        mergeUnknownObjects?: boolean;
+        defaultUndefined?: boolean;
+    }) => Operation[];
+    createInitialize: (obj: any, oid: ObjectIdentifier) => Operation[];
+    createSet: (oid: ObjectIdentifier, key: PropertyName, value: any) => Operation[];
+    createRemove: (oid: ObjectIdentifier, key: PropertyName) => Operation[];
+    createListPush: (oid: ObjectIdentifier, value: any) => Operation[];
+    createListAdd: (oid: ObjectIdentifier, value: any) => Operation[];
+    createListInsert: (oid: ObjectIdentifier, index: number, value: any) => Operation[];
+    createListRemove: (oid: ObjectIdentifier, value: any, only?: 'first' | 'last') => Operation[];
+    createListDelete: (oid: ObjectIdentifier, index: number, count?: number) => Operation[];
+    createListMoveByRef: (oid: ObjectIdentifier, value: ObjectRef | FileRef, index: number) => Operation[];
+    createListMoveByIndex: (oid: ObjectIdentifier, fromIndex: number, toIndex: number) => Operation[];
+    createDelete: (oid: ObjectIdentifier) => Operation[];
+    createDeleteAll: (oids: ObjectIdentifier[]) => Operation[];
+}

package/dist/esm/presence.d.ts

@@ -0,0 +1,29 @@
+export interface UserInfo<Profile, Presence> {
+    /**
+     * @deprecated - include the ID in your Profile data instead.
+     *
+     * This is the ID representing the user who is utilizing a
+     * replica client to connect to the storage network.
+     * One user may have multiple replica clients active at once,
+     * but their presence will only reflect the most recent
+     * replica used.
+     */
+    id: string;
+    /**
+     * This is the ID representing the replica client that is
+     * connected to the storage network. This is used to
+     * identify the client when sending messages to it.
+     */
+    replicaId: string;
+    /**
+     * This is the user's server profile. This data is associated
+     * with the logged in user of the app and cannot be modified
+     * by the local replica directly.
+     */
+    profile: Profile;
+    /**
+     * Presence info which can update frequently as a replica
+     * makes changes. The shape of presence is up to you.
+     */
+    presence: Presence;
+}

package/dist/esm/protocol.d.ts

@@ -0,0 +1,145 @@
+import { DocumentBaseline } from './baseline.js';
+import { Operation } from './operation.js';
+import { UserInfo } from './presence.js';
+export type HeartbeatMessage = {
+    type: 'heartbeat';
+    timestamp: string;
+    replicaId: string;
+};
+export type HeartbeatResponseMessage = {
+    type: 'heartbeat-response';
+};
+/**
+ * Used by clients to indicate they have
+ * successfully applied all operations from the
+ * server up to this one. Uses the nonce from the
+ * operation rebroadcast message as the ack.
+ */
+export type AckMessage = {
+    type: 'ack';
+    replicaId: string;
+    timestamp?: string;
+    nonce?: string;
+};
+export type OperationMessage = {
+    type: 'op';
+    replicaId: string;
+    operations: Operation[];
+    timestamp: string;
+};
+export type OperationRebroadcastMessage = {
+    type: 'op-re';
+    operations: Operation[];
+    baselines?: DocumentBaseline[];
+    replicaId: string;
+    globalAckTimestamp: string | undefined;
+    ackThisNonce?: string;
+};
+export type SyncMessage = {
+    type: 'sync';
+    /** This client's replica ID */
+    replicaId: string;
+    /** the logical time this message was sent */
+    timestamp: string;
+    /** Any new operations created since the requested time */
+    operations: Operation[];
+    /** Any new baselines created since the requested time */
+    baselines: DocumentBaseline[];
+    /** the schema version known by this client */
+    schemaVersion: number;
+    /**
+     * the client may have lost its local data, in which
+     * case it may set this flag to be treated as a new client
+     * and receive a full baseline
+     */
+    resyncAll?: boolean;
+    /**
+     * timestamp of when the replica changes began. null means
+     * full changeset from start of time
+     */
+    since: string | null;
+};
+export type SyncResponseMessage = {
+    type: 'sync-resp';
+    operations: Operation[];
+    baselines: DocumentBaseline[];
+    /**
+     * If this flag is set, the client should discard local data
+     * and reset to incoming data only. Used when a client requested
+     * resyncAll in its sync message, or for clients which have been
+     * offline for too long. When specified true, provideChangesSince
+     * should be ignored.
+     */
+    overwriteLocalData: boolean;
+    /**
+     * Update client on the global ack
+     */
+    globalAckTimestamp: string | undefined;
+    /**
+     * A map of connected clients' presences values
+     */
+    peerPresence: Record<string, UserInfo<any, any>>;
+    /**
+     * The timestamp sent in the original sync message -
+     * this confirms the server has received the client's
+     * state up to this point. Subsequent syncs should not
+     * include operations or baselines older than this timestamp.
+     */
+    ackedTimestamp: string;
+    /**
+     * The client should respond with a sync-ack containing
+     * this nonce to confirm it has received this message if
+     * it is not undefined
+     */
+    ackThisNonce?: string;
+};
+/** @deprecated use ack */
+export type SyncAckMessage = {
+    type: 'sync-ack';
+    /** The client's replica ID */
+    replicaId: string;
+    /** the logical time this message was sent */
+    timestamp: string;
+    /** the nonce sent in the sync-resp message */
+    nonce: string;
+};
+export type PresenceUpdateMessage = {
+    type: 'presence-update';
+    /** The client's replica ID */
+    replicaId: string;
+    /** new presence value */
+    presence: any;
+};
+export type PresenceChangedMessage = {
+    type: 'presence-changed';
+    /** The client's replica ID */
+    replicaId: string;
+    userInfo: UserInfo<any, any>;
+};
+/**
+ * This is only emitted when all of a user's replicas
+ * go offline.
+ */
+export type PresenceOfflineMessage = {
+    type: 'presence-offline';
+    userId: string;
+    /** The last replicaID seen by the server before the user was offline */
+    replicaId: string;
+};
+export type GlobalAckMessage = {
+    type: 'global-ack';
+    timestamp: string;
+};
+export type ForbiddenMessage = {
+    type: 'forbidden';
+};
+export type ServerAckMessage = {
+    type: 'server-ack';
+    timestamp: string;
+};
+export type ServerNeedSinceMessage = {
+    type: 'need-since';
+    since: string | null;
+};
+export type ClientMessage = HeartbeatMessage | SyncMessage | OperationMessage | AckMessage | SyncAckMessage | PresenceUpdateMessage;
+export type ServerMessage = HeartbeatResponseMessage | SyncResponseMessage | OperationRebroadcastMessage | PresenceChangedMessage | PresenceOfflineMessage | GlobalAckMessage | ForbiddenMessage | ServerAckMessage | ServerNeedSinceMessage;

package/dist/esm/refs.d.ts

@@ -0,0 +1,7 @@
+import { FileRef } from './files.js';
+import { ObjectRef } from './operation.js';
+export declare function isRef(obj: any): obj is ObjectRef | FileRef;
+export declare function compareRefs(a: any, b: any): boolean;
+export type Ref = ObjectRef | FileRef;
+export declare function makeObjectRef(oid: string): ObjectRef;
+export declare function makeFileRef(oid: string): FileRef;

package/dist/esm/replica.d.ts

@@ -0,0 +1,28 @@
+export interface ReplicaInfo {
+    id: string;
+    ackedLogicalTime: string | null;
+}
+/**
+ * Different token types allow different replica client behaviors.
+ * - Realtime: allows the client to subscribe to realtime events.
+ * - Push: allows the client to push and pull data with HTTP, but not use realtime.
+ * - PassivePush: allows the client to push and pull data with HTTP, but offline changes
+ *     will be discarded on reconnect.
+ * - PassiveRealtime: allows the client to subscribe to realtime events, but offline changes
+ * 		 will be discarded on reconnect.
+ * - ReadOnlyPull: the client may only pull changes using HTTP. It may not subscribe
+ *     to realtime events or push changes.
+ * - ReadOnlyRealtime: the client may only subscribe to realtime events or pull from HTTP.
+ *     It may not push changes.
+ *
+ * Choosing the right token type can optimize client storage metrics significantly when
+ * many replicas are connecting to a library.
+ */
+export declare enum ReplicaType {
+    Realtime = 0,
+    Push = 1,
+    PassiveRealtime = 2,
+    PassivePush = 3,
+    ReadOnlyPull = 4,
+    ReadOnlyRealtime = 5
+}

package/dist/esm/schema/children.d.ts

@@ -0,0 +1,2 @@
+import { StorageFieldSchema, StorageFieldsSchema } from './types.js';
+export declare function getChildFieldSchema(schema: StorageFieldSchema | StorageFieldsSchema, key: string | number): StorageFieldSchema | null;

package/dist/esm/schema/defaults.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/schema/fieldHelpers.d.ts

@@ -0,0 +1,35 @@
+import { ShapeFromFieldsWithDefaults, StorageAnyFieldSchema, StorageArrayFieldSchema, StorageBooleanFieldSchema, StorageFieldSchema, StorageFieldsSchema, StorageFileFieldSchema, StorageMapFieldSchema, StorageNumberFieldSchema, StorageObjectFieldSchema, StorageStringFieldSchema } from './types.js';
+export declare const fields: {
+    object: <Props extends StorageFieldsSchema>(args: {
+        properties: Props;
+        nullable?: boolean;
+        default?: ShapeFromFieldsWithDefaults<Props> | (() => ShapeFromFieldsWithDefaults<Props>);
+    }) => StorageObjectFieldSchema<Props>;
+    array: <T extends StorageFieldSchema>(args: {
+        items: T;
+        nullable?: boolean;
+    }) => StorageArrayFieldSchema<T>;
+    string: (args?: {
+        nullable?: boolean;
+        default?: string | (() => string);
+        options?: string[];
+    }) => StorageStringFieldSchema;
+    number: (args?: {
+        nullable?: boolean;
+        default?: number | (() => number);
+    }) => StorageNumberFieldSchema;
+    boolean: (args?: {
+        nullable?: boolean;
+        default?: boolean | (() => boolean);
+    }) => StorageBooleanFieldSchema;
+    any: <TShape>(args?: {
+        default?: TShape;
+    }) => StorageAnyFieldSchema<TShape>;
+    map: <T_1 extends StorageFieldSchema>(args: {
+        values: T_1;
+    }) => StorageMapFieldSchema<T_1>;
+    file: (args?: {
+        nullable?: boolean;
+        downloadRemote?: boolean;
+    }) => StorageFileFieldSchema;
+};

package/dist/esm/schema/fields.d.ts

@@ -0,0 +1,10 @@
+import type { StorageFieldSchema, StorageCollectionSchema } from './types.js';
+export declare function isNullable(field: StorageFieldSchema): boolean | undefined;
+export declare function hasDefault(field: StorageFieldSchema | undefined): boolean;
+export declare function getDefault(field: StorageFieldSchema | undefined): any;
+export declare function isPrunePoint(field: StorageFieldSchema): boolean;
+export declare function addFieldDefaults(collection: StorageCollectionSchema, value: any): any;
+export declare function traverseCollectionFieldsAndApplyDefaults(value: any, field: StorageFieldSchema): any;
+export declare function getFieldDefault(field: StorageFieldSchema): any;
+export declare function removeExtraProperties(collection: StorageCollectionSchema, value: any): any;
+export declare function traverseCollectionFieldsAndRemoveExtraProperties(value: any, field: StorageFieldSchema): void;

package/dist/esm/schema/index.d.ts

@@ -0,0 +1,54 @@
+import { CollectionCompoundIndices, StorageCollectionSchema, StorageFieldsSchema, StorageSchema, StorageSyntheticIndices } from './types.js';
+export declare function collection<Fields extends StorageFieldsSchema, Synthetics extends StorageSyntheticIndices<Fields>, Compounds extends CollectionCompoundIndices<Fields, Synthetics>>({ synthetics, indexes, ...input }: StorageCollectionSchema<Fields, Synthetics, Compounds>): StorageCollectionSchema<Fields, Synthetics, Compounds>;
+export declare function schema<Schema extends StorageSchema<{
+    [key: string]: StorageCollectionSchema<any, any, any>;
+}>>(input: Schema): StorageSchema;
+export declare namespace schema {
+    var collection: typeof import("./index.js").collection;
+    var fields: {
+        object: <Props extends StorageFieldsSchema>(args: {
+            properties: Props;
+            nullable?: boolean | undefined;
+            default?: import("./types.js").ShapeFromFieldsWithDefaults<Props> | (() => import("./types.js").ShapeFromFieldsWithDefaults<Props>) | undefined;
+        }) => import("./types.js").StorageObjectFieldSchema<Props>;
+        array: <T extends import("./types.js").StorageFieldSchema>(args: {
+            items: T;
+            nullable?: boolean | undefined;
+        }) => import("./types.js").StorageArrayFieldSchema<T>;
+        string: (args?: {
+            nullable?: boolean | undefined;
+            default?: string | (() => string) | undefined;
+            options?: string[] | undefined;
+        } | undefined) => import("./types.js").StorageStringFieldSchema;
+        number: (args?: {
+            nullable?: boolean | undefined;
+            default?: number | (() => number) | undefined;
+        } | undefined) => import("./types.js").StorageNumberFieldSchema;
+        boolean: (args?: {
+            nullable?: boolean | undefined;
+            default?: boolean | (() => boolean) | undefined;
+        } | undefined) => import("./types.js").StorageBooleanFieldSchema;
+        any: <TShape>(args?: {
+            default?: TShape | undefined;
+        } | undefined) => import("./types.js").StorageAnyFieldSchema<TShape>;
+        map: <T_1 extends import("./types.js").StorageFieldSchema>(args: {
+            values: T_1;
+        }) => import("./types.js").StorageMapFieldSchema<T_1>;
+        file: (args?: {
+            nullable?: boolean | undefined;
+            downloadRemote?: boolean | undefined;
+        } | undefined) => import("./types.js").StorageFileFieldSchema;
+    };
+    var generated: {
+        id: (() => string) & {
+            slug: () => string;
+            isCuid: (cuid: string) => boolean;
+            isSlug: (slug: string) => boolean;
+        };
+    };
+}
+export * from './types.js';
+export * from './indexFilters.js';
+export * from './fields.js';
+export * from './validation.js';
+export * from './children.js';

package/dist/esm/schema/indexFilters.d.ts

@@ -0,0 +1,6 @@
+import { CollectionCompoundIndexFilter, CollectionFilter, MatchCollectionIndexFilter, RangeCollectionIndexFilter, SortIndexFilter, StartsWithIndexFilter } from './types.js';
+export declare function isMatchIndexFilter(filter: CollectionFilter): filter is MatchCollectionIndexFilter;
+export declare function isRangeIndexFilter(filter: CollectionFilter): filter is RangeCollectionIndexFilter;
+export declare function isCompoundIndexFilter(filter: CollectionFilter): filter is CollectionCompoundIndexFilter;
+export declare function isStartsWithIndexFilter(filter: CollectionFilter): filter is StartsWithIndexFilter;
+export declare function isSortIndexFilter(filter: CollectionFilter): filter is SortIndexFilter;

package/dist/esm/schema/types/collection.d.ts

@@ -0,0 +1,23 @@
+import { CollectionCompoundIndices } from './compounds.js';
+import { StorageFieldsSchema } from './fields.js';
+import { DirectIndexableFieldName, StorageSyntheticIndices } from './synthetics.js';
+/**
+ * The main collection schema
+ */
+export type StorageCollectionSchema<Fields extends StorageFieldsSchema = StorageFieldsSchema, Synthetics extends StorageSyntheticIndices<Fields> = StorageSyntheticIndices<Fields>, Compounds extends CollectionCompoundIndices<Fields, Synthetics> = CollectionCompoundIndices<Fields, Synthetics>> = {
+    name: string;
+    /**
+     * Your primary key must be a string, number, or boolean field. It must also
+     * not be rewritten.
+     */
+    primaryKey: DirectIndexableFieldName<Fields>;
+    fields: Fields;
+    indexes?: Synthetics;
+    compounds?: Compounds;
+    /**
+     * @deprecated - plural name is the key used to index this collection in the schema. this field is no longer used.
+     */
+    pluralName?: string;
+    /** @deprecated - use "indexes" */
+    synthetics?: Synthetics;
+};

package/dist/esm/schema/types/compounds.d.ts

@@ -0,0 +1,11 @@
+import { StorageArrayFieldSchema, StorageBooleanFieldSchema, StorageFieldsSchema, StorageNumberFieldSchema, StorageStringFieldSchema } from './fields.js';
+import { DirectIndexableFieldName, StorageSyntheticIndices } from './synthetics.js';
+type PrimitiveArrayFields<Fields extends StorageFieldsSchema> = {
+    [K in keyof Fields as Fields[K] extends StorageArrayFieldSchema<infer U> ? U extends StorageStringFieldSchema | StorageNumberFieldSchema | StorageBooleanFieldSchema ? K : never : never]: Fields[K];
+};
+type PrimitiveArrayFieldName<Fields extends StorageFieldsSchema> = Extract<keyof PrimitiveArrayFields<Fields>, string>;
+export type CollectionCompoundIndex<Fields extends StorageFieldsSchema, Synthetics extends StorageSyntheticIndices<Fields>> = {
+    of: (DirectIndexableFieldName<Fields> | PrimitiveArrayFieldName<Fields> | Extract<keyof Synthetics, string>)[];
+};
+export type CollectionCompoundIndices<Fields extends StorageFieldsSchema, Synthetics extends StorageSyntheticIndices<Fields>> = Record<string, CollectionCompoundIndex<Fields, Synthetics>>;
+export {};

package/dist/esm/schema/types/fields.d.ts

@@ -0,0 +1,55 @@
+export type StorageStringFieldSchema = {
+    type: 'string';
+    nullable?: boolean;
+    default?: string | (() => string);
+    /** Limit the values to a certain set of options */
+    options?: string[];
+};
+export type StorageNumberFieldSchema = {
+    type: 'number';
+    nullable?: boolean;
+    default?: number | (() => number);
+};
+export type StorageBooleanFieldSchema = {
+    type: 'boolean';
+    nullable?: boolean;
+    default?: boolean | (() => boolean);
+};
+export type StorageArrayFieldSchema<TItems extends StorageFieldSchema> = {
+    type: 'array';
+    items: TItems;
+    nullable?: boolean;
+};
+export type StorageObjectFieldSchema<Props extends StorageFieldsSchema> = {
+    type: 'object';
+    properties: Props;
+    nullable?: boolean;
+    default?: Record<string, any> | (() => Record<string, any>);
+};
+export type StorageAnyFieldSchema<TShape = any> = {
+    type: 'any';
+    default?: TShape;
+};
+export type StorageMapFieldSchema<V extends StorageFieldSchema> = {
+    type: 'map';
+    values: V;
+};
+export type StorageFileFieldSchema = {
+    type: 'file';
+    nullable?: boolean;
+    /**
+     * Instructs the client to download synced files to local storage on first request for offline use.
+     * Leave this false to save storage space on the client, at the cost of requiring a network
+     * connection to use files created by other devices.
+     */
+    downloadRemote?: boolean;
+};
+export type StorageFieldSchema = StorageStringFieldSchema | StorageNumberFieldSchema | StorageBooleanFieldSchema | StorageArrayFieldSchema<any> | StorageObjectFieldSchema<any> | StorageAnyFieldSchema | StorageMapFieldSchema<any> | StorageFileFieldSchema;
+export type StorageFieldsSchema = {
+    [key: string]: StorageFieldSchema;
+};
+export type StorageIndexableFields<Fields extends StorageFieldsSchema> = {
+    [K in keyof Fields]: Fields[K] extends {
+        indexed: boolean;
+    } ? K : never;
+};

package/dist/esm/schema/types/filters.d.ts

@@ -0,0 +1,29 @@
+export type MatchCollectionIndexFilter = {
+    where: string;
+    equals: any;
+    order?: 'asc' | 'desc';
+};
+export type RangeCollectionIndexFilter = {
+    where: string;
+    gte?: any;
+    lte?: any;
+    gt?: any;
+    lt?: any;
+    order?: 'asc' | 'desc';
+};
+export type CollectionCompoundIndexFilter = {
+    where: string;
+    match: Record<string, any>;
+    order: 'asc' | 'desc';
+};
+export type SortIndexFilter = {
+    where: string;
+    order: 'asc' | 'desc';
+};
+export type StartsWithIndexFilter = {
+    where: string;
+    startsWith: string;
+    order?: 'asc' | 'desc';
+};
+export type CollectionIndexFilter = MatchCollectionIndexFilter | RangeCollectionIndexFilter | CollectionCompoundIndexFilter | StartsWithIndexFilter | SortIndexFilter;
+export type CollectionFilter = CollectionIndexFilter;

package/dist/esm/schema/types/shapes.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import { StorageCollectionSchema } from './collection.js';
+import { StorageArrayFieldSchema, StorageFieldSchema, StorageFieldsSchema, StorageMapFieldSchema, StorageObjectFieldSchema } from './fields.js';
+type StoragePropertyIsNullable<T extends StorageFieldSchema> = T extends {
+    nullable?: boolean;
+} ? T['nullable'] extends boolean ? true : false : T['type'] extends 'any' ? true : false;
+export type BaseShapeFromProperty<T extends StorageFieldSchema> = T['type'] extends 'string' ? string : T['type'] extends 'number' ? number : T['type'] extends 'boolean' ? boolean : T extends StorageArrayFieldSchema<infer U> ? ShapeFromProperty<U>[] : T extends StorageObjectFieldSchema<infer U> ? ShapeFromFields<U> : T extends StorageMapFieldSchema<any> ? Record<string, ShapeFromProperty<T['values']>> : T['type'] extends 'any' ? any : T['type'] extends 'file' ? File : never;
+export type ShapeFromProperty<T extends StorageFieldSchema> = StoragePropertyIsNullable<T> extends true ? BaseShapeFromProperty<T> | null : BaseShapeFromProperty<T>;
+export type ShapeFromFields<T extends StorageFieldsSchema> = {
+    [K in keyof T]: ShapeFromProperty<T[K]>;
+};
+export type StorageDocument<Collection extends StorageCollectionSchema<any, any, any>> = ShapeFromFields<Collection['fields']>;
+type StoragePropertyIsOptional<T extends StorageFieldSchema> = StoragePropertyIsNullable<T> extends true ? true : T extends {
+    default?: any;
+} ? true : T['type'] extends 'any' ? true : T['type'] extends 'array' ? true : T['type'] extends 'map' ? true : false;
+export type ShapeFromFieldsWithDefaults<T extends StorageFieldsSchema> = {
+    [K in keyof T as StoragePropertyIsOptional<T[K]> extends true ? K : never]?: ShapeFromProperty<T[K]>;
+} & {
+    [K in keyof T as StoragePropertyIsOptional<T[K]> extends true ? never : K]: ShapeFromProperty<T[K]>;
+};
+export type StorageDocumentInit<Collection extends StorageCollectionSchema<any, any, any>> = ShapeFromFieldsWithDefaults<Collection['fields']>;
+export type FieldsFromShape<Shape extends Record<string, unknown>> = {
+    [K in keyof Shape]: StorageFieldSchema;
+};
+export {};