@live-state/sync 0.0.1-alpha.1

package/dist/index-sSVirsfN.d.ts

@@ -0,0 +1,458 @@
+import { z, ZodUnion } from 'zod';
+
+declare const mutationsMsgSchema: z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"MUTATE">;
+    resource: z.ZodString;
+    resourceId: z.ZodString;
+    payload: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: ZodUnion<[ZodUnion<[ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>, z.ZodDate]>;
+        _meta: z.ZodOptional<z.ZodObject<{
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp?: string | undefined;
+        }, {
+            timestamp?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "MUTATE";
+    resource: string;
+    resourceId: string;
+    payload: Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>;
+}, {
+    _id: string;
+    type: "MUTATE";
+    resource: string;
+    resourceId: string;
+    payload: Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>;
+}>;
+type MutationMessage = z.infer<typeof mutationsMsgSchema>;
+declare const clientMessageSchema: ZodUnion<[z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"SUBSCRIBE">;
+    resource: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "SUBSCRIBE";
+    resource: string;
+}, {
+    _id: string;
+    type: "SUBSCRIBE";
+    resource: string;
+}>, z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"MUTATE">;
+    resource: z.ZodString;
+    resourceId: z.ZodString;
+    payload: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: ZodUnion<[ZodUnion<[ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>, z.ZodDate]>;
+        _meta: z.ZodOptional<z.ZodObject<{
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp?: string | undefined;
+        }, {
+            timestamp?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "MUTATE";
+    resource: string;
+    resourceId: string;
+    payload: Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>;
+}, {
+    _id: string;
+    type: "MUTATE";
+    resource: string;
+    resourceId: string;
+    payload: Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>;
+}>, z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"SYNC">;
+    lastSyncedAt: z.ZodOptional<z.ZodString>;
+    resources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "SYNC";
+    lastSyncedAt?: string | undefined;
+    resources?: string[] | undefined;
+}, {
+    _id: string;
+    type: "SYNC";
+    lastSyncedAt?: string | undefined;
+    resources?: string[] | undefined;
+}>]>;
+type ClientMessage = z.infer<typeof clientMessageSchema>;
+declare const serverMessageSchema: ZodUnion<[z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"MUTATE">;
+    resource: z.ZodString;
+    resourceId: z.ZodString;
+    payload: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: ZodUnion<[ZodUnion<[ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>, z.ZodDate]>;
+        _meta: z.ZodOptional<z.ZodObject<{
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp?: string | undefined;
+        }, {
+            timestamp?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "MUTATE";
+    resource: string;
+    resourceId: string;
+    payload: Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>;
+}, {
+    _id: string;
+    type: "MUTATE";
+    resource: string;
+    resourceId: string;
+    payload: Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>;
+}>, z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"SYNC">;
+    resource: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: ZodUnion<[ZodUnion<[ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>, z.ZodDate]>;
+        _meta: z.ZodOptional<z.ZodObject<{
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp?: string | undefined;
+        }, {
+            timestamp?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "SYNC";
+    resource: string;
+    data: Record<string, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>;
+}, {
+    _id: string;
+    type: "SYNC";
+    resource: string;
+    data: Record<string, Record<string, {
+        value: string | number | boolean | Date;
+        _meta?: {
+            timestamp?: string | undefined;
+        } | undefined;
+    }>>;
+}>, z.ZodObject<{
+    _id: z.ZodString;
+    type: z.ZodLiteral<"REJECT">;
+    resource: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _id: string;
+    type: "REJECT";
+    resource: string;
+}, {
+    _id: string;
+    type: "REJECT";
+    resource: string;
+}>]>;
+type ServerMessage = z.infer<typeof serverMessageSchema>;
+
+type LiveTypeMeta = {};
+type MutationType = "set";
+declare abstract class LiveType<Value = any, Meta extends LiveTypeMeta = LiveTypeMeta, EncodeInput = Partial<Value> | Value, DecodeInput = {
+    value: Value;
+    _meta: keyof Meta extends never ? never : Meta;
+}> {
+    readonly _value: Value;
+    readonly _meta: Meta;
+    readonly _encodeInput: EncodeInput;
+    readonly _decodeInput: DecodeInput;
+    abstract encodeMutation(mutationType: MutationType, input: EncodeInput, timestamp: string): DecodeInput;
+    /**
+     * Merges the materialized shape with the encoded mutation
+     * @param mutationType The type of mutation
+     * @param encodedMutation The encoded mutation
+     * @param materializedShape The materialized shape
+     * @returns A tuple of the new materialized shape and the accepted diff
+     */
+    abstract mergeMutation(mutationType: MutationType, encodedMutation: DecodeInput, materializedShape?: MaterializedLiveType<LiveType<Value, Meta>>): [MaterializedLiveType<LiveType<Value, Meta>>, DecodeInput | null];
+}
+type LiveTypeAny = LiveType<any, LiveTypeMeta, any, any>;
+type InferLiveType<T extends LiveTypeAny> = T["_value"] extends Record<string, LiveTypeAny> ? {
+    [K in keyof T["_value"]]: InferLiveType<T["_value"][K]>;
+} : T["_value"];
+type InferIndex<T extends LiveTypeAny> = string;
+
+declare class OptionalLiveType<T extends LiveTypeAny> extends LiveType<T["_value"] | undefined, T["_meta"], T["_encodeInput"], T["_decodeInput"]> {
+    encodeMutation(mutationType: MutationType, input: T["_value"] | undefined, timestamp: string): string;
+    mergeMutation(mutationType: MutationType, encodedMutation: T["_decodeInput"], materializedShape?: MaterializedLiveType<LiveType<T["_value"] | undefined, T["_meta"], T["_value"] | Partial<T["_value"] | undefined>, T["_decodeInput"]>> | undefined): [
+        MaterializedLiveType<LiveType<T["_value"] | undefined, T["_meta"], T["_value"] | Partial<T["_value"] | undefined>, T["_decodeInput"]>>,
+        T["_decodeInput"] | null
+    ];
+}
+type LiveAtomicTypeMeta = {
+    timestamp: string;
+} & LiveTypeMeta;
+declare abstract class LiveAtomicType<Value = any, Meta extends LiveAtomicTypeMeta = LiveAtomicTypeMeta, EncodeInput = Partial<Value> | Value> extends LiveType<Value, Meta, EncodeInput> {
+    constructor();
+    optional(): OptionalLiveType<this>;
+}
+declare class LiveNumber extends LiveAtomicType<number> {
+    encodeMutation(mutationType: MutationType, input: Partial<number>, timestamp: string): {
+        value: number;
+        _meta: {
+            timestamp: string;
+        };
+    };
+    mergeMutation(mutationType: MutationType, encodedMutation: {
+        value: number;
+        _meta: {
+            timestamp: string;
+        };
+    }, materializedShape?: MaterializedLiveType<LiveNumber>): [
+        MaterializedLiveType<LiveNumber>,
+        {
+            value: number;
+            _meta: {
+                timestamp: string;
+            };
+        } | null
+    ];
+    static create(): LiveNumber;
+}
+declare const number: typeof LiveNumber.create;
+declare class LiveString extends LiveAtomicType<string> {
+    encodeMutation(mutationType: MutationType, input: Partial<string>, timestamp: string): {
+        value: string;
+        _meta: {
+            timestamp: string;
+        };
+    };
+    mergeMutation(mutationType: MutationType, encodedMutation: {
+        value: string;
+        _meta: {
+            timestamp: string;
+        };
+    }, materializedShape?: MaterializedLiveType<LiveString>): [
+        MaterializedLiveType<LiveString>,
+        {
+            value: string;
+            _meta: {
+                timestamp: string;
+            };
+        } | null
+    ];
+    static create(): LiveString;
+}
+declare const string: typeof LiveString.create;
+
+type InferLiveObjectWithoutRelations<T extends LiveObjectAny> = {
+    [K in keyof T["fields"]]: InferLiveType<T["fields"][K]>;
+};
+type InferLiveObject<T extends LiveObjectAny> = InferLiveObjectWithoutRelations<T> & {
+    [K in keyof T["relations"]]: T["relations"][K]["type"] extends "one" ? InferLiveObject<T["relations"][K]["entity"]> : InferLiveObject<T["relations"][K]["entity"]>[];
+};
+type InferRelationalColumns<T extends Record<string, RelationAny>> = {
+    [K in keyof T as T[K] extends Relation<any, any, any, infer ColumnName, any, any> ? ColumnName extends string ? ColumnName : never : never]: T[K]["type"] extends "one" ? T[K] extends Relation<infer Entity, any, any, any, any, any> ? T[K]["required"] extends true ? InferIndex<Entity> : InferIndex<Entity> | undefined : never : never;
+};
+type InferLiveObjectWithRelationalIds<T extends LiveObjectAny> = keyof T["relations"] extends string ? InferLiveObjectWithoutRelations<T> & InferRelationalColumns<T["relations"]> : InferLiveObjectWithoutRelations<T>;
+type LiveObjectMutationInput<TSchema extends LiveObjectAny> = InferLiveObjectWithRelationalIds<TSchema>;
+declare class LiveObject<TName extends string, TSchema extends Record<string, LiveTypeAny>, TRelations extends Record<string, RelationAny>> extends LiveType<TSchema, LiveTypeMeta, LiveObjectMutationInput<any>, Record<string, MaterializedLiveType<LiveTypeAny>>> {
+    readonly name: TName;
+    readonly fields: TSchema;
+    readonly relations: TRelations;
+    constructor(name: TName, fields: TSchema, relations?: TRelations);
+    encodeMutation(_mutationType: MutationType, input: LiveObjectMutationInput<this>, timestamp: string): Record<string, any>;
+    mergeMutation(mutationType: MutationType, encodedMutations: Record<string, MaterializedLiveType<LiveTypeAny>>, materializedShape?: MaterializedLiveType<this> | undefined): [MaterializedLiveType<this>, Record<string, any> | null];
+    setRelations<TRelations extends Record<string, RelationAny>>(relations: TRelations): LiveObject<this["name"], this["fields"], TRelations>;
+    static create<TName extends string, TSchema extends Record<string, LiveTypeAny>>(name: TName, schema: TSchema): LiveObject<TName, TSchema, never>;
+}
+declare const object: typeof LiveObject.create;
+type LiveObjectAny = LiveObject<string, Record<string, LiveTypeAny>, any>;
+declare class Relation<TEntity extends LiveObjectAny, TSourceEntity extends LiveObjectAny, TType extends "one" | "many", TRelationalColumn extends keyof TSourceEntity["fields"], TForeignColumn extends keyof TEntity["fields"], TRequired extends boolean> extends LiveType<InferIndex<TEntity>, {
+    timestamp: string;
+} & LiveTypeMeta> {
+    readonly entity: TEntity;
+    readonly type: TType;
+    readonly required: TRequired;
+    readonly relationalColumn?: TRelationalColumn;
+    readonly foreignColumn?: TForeignColumn;
+    readonly sourceEntity: TSourceEntity;
+    private constructor();
+    encodeMutation(mutationType: MutationType, input: string, timestamp: string): {
+        value: string;
+        _meta: {
+            timestamp: string;
+        };
+    };
+    mergeMutation(mutationType: MutationType, encodedMutation: {
+        value: string;
+        _meta: {
+            timestamp: string;
+        };
+    }, materializedShape?: MaterializedLiveType<LiveString> | undefined): [
+        MaterializedLiveType<LiveString>,
+        {
+            value: string;
+            _meta: {
+                timestamp: string;
+            };
+        } | null
+    ];
+    static createOneFactory<TOriginEntity extends LiveObjectAny>(): <TEntity extends LiveObjectAny, TColumn extends keyof TOriginEntity["fields"], TRequired extends boolean = false>(entity: TEntity, column: TColumn, required?: TRequired) => Relation<TEntity, TOriginEntity, "one", TColumn, never, TRequired>;
+    static createManyFactory<TOriginEntity extends LiveObjectAny>(): <TEntity extends LiveObjectAny, TColumn extends keyof TEntity["fields"], TRequired extends boolean = false>(entity: TEntity, foreignColumn: TColumn, required?: TRequired) => Relation<TEntity, TOriginEntity, "many", never, TColumn, TRequired>;
+}
+type RelationAny = Relation<LiveObjectAny, LiveObjectAny, any, any, any, any>;
+declare const createRelations: <TSourceObject extends LiveObjectAny, TRelations extends Record<string, RelationAny>>(liveObject: TSourceObject, factory: (connectors: {
+    one: ReturnType<typeof Relation.createOneFactory<TSourceObject>>;
+    many: ReturnType<typeof Relation.createManyFactory<TSourceObject>>;
+}) => TRelations) => RelationsDecl<TSourceObject["name"], TRelations>;
+type MaterializedLiveType<T extends LiveTypeAny> = keyof T["_meta"] extends never ? {
+    value: T["_value"] extends Record<string, LiveTypeAny> ? {
+        [K in keyof T["_value"]]: MaterializedLiveType<T["_value"][K]>;
+    } : T["_value"];
+} : {
+    value: T["_value"] extends Record<string, LiveTypeAny> ? {
+        [K in keyof T["_value"]]: MaterializedLiveType<T["_value"][K]>;
+    } : T["_value"];
+    _meta: T["_meta"];
+};
+type MaterializedLiveObject<T extends LiveObjectAny> = MaterializedLiveType<T> & {
+    [K in keyof T["relations"]]: InferIndex<T["relations"][K]["entity"]>;
+};
+declare const inferValue: <T extends LiveTypeAny>(type: MaterializedLiveType<T>) => InferLiveType<T>;
+type ExtractObjectValues<T> = T[keyof T];
+type RelationsDecl<TObjectName extends string = string, TRelations extends Record<string, RelationAny> = Record<string, RelationAny>> = {
+    $type: "relations";
+    objectName: TObjectName;
+    relations: TRelations;
+};
+type ParseRelationsFromSchema<TRawSchema extends RawSchema, TObjectName extends string> = ExtractObjectValues<{
+    [K in keyof TRawSchema]: TRawSchema[K] extends RelationsDecl<infer TObjectName_, any> ? TObjectName_ extends TObjectName ? {
+        [K2 in keyof TRawSchema[K]["relations"]]: Relation<ParseObjectFromSchema<TRawSchema, TRawSchema[K]["relations"][K2]["entity"]["name"]>, TRawSchema[K]["relations"][K2]["sourceEntity"], TRawSchema[K]["relations"][K2]["type"], Exclude<TRawSchema[K]["relations"][K2]["relationalColumn"], undefined>, Exclude<TRawSchema[K]["relations"][K2]["foreignColumn"], undefined>, TRawSchema[K]["relations"][K2]["required"]>;
+    } : never : never;
+}>;
+type ParseObjectFromSchema<TRawSchema extends RawSchema, TObjectName extends string> = ExtractObjectValues<{
+    [K in keyof TRawSchema]: TRawSchema[K] extends LiveObjectAny ? TRawSchema[K]["name"] extends TObjectName ? LiveObject<TRawSchema[K]["name"], TRawSchema[K]["fields"], ParseRelationsFromSchema<TRawSchema, TRawSchema[K]["name"]>> : never : never;
+}>;
+type RawSchema = Record<string, LiveObjectAny | RelationsDecl>;
+type Schema<TRawSchema extends RawSchema> = {
+    [K in keyof TRawSchema as TRawSchema[K] extends LiveObjectAny ? TRawSchema[K]["name"] : never]: TRawSchema[K] extends LiveObjectAny ? ParseObjectFromSchema<TRawSchema, TRawSchema[K]["name"]> : never;
+};
+declare const createSchema: <TRawSchema extends RawSchema>(schema: TRawSchema) => Schema<TRawSchema>;
+
+export { type ClientMessage as C, type InferLiveObject as I, type LiveObjectAny as L, type MaterializedLiveType as M, Relation as R, type Schema as S, type MutationMessage as a, type ServerMessage as b, type InferLiveObjectWithRelationalIds as c, type LiveObjectMutationInput as d, LiveObject as e, createRelations as f, type MaterializedLiveObject as g, createSchema as h, inferValue as i, LiveNumber as j, LiveString as k, type LiveTypeMeta as l, type MutationType as m, number as n, object as o, LiveType as p, type LiveTypeAny as q, type InferLiveType as r, string as s, type InferIndex as t };

package/dist/index.cjs

@@ -0,0 +1 @@
+'use strict';var o=class{_value;_meta;_encodeInput;_decodeInput};var T=class extends o{encodeMutation(n,t,e){throw new Error("Method not implemented.")}mergeMutation(n,t,e){throw new Error("Method not implemented.")}},s=class extends o{constructor(){super(),this.optional=this.optional.bind(this);}optional(){return new T}},y=class a extends s{encodeMutation(n,t,e){return {value:t,_meta:{timestamp:e}}}mergeMutation(n,t,e){return e&&e._meta.timestamp.localeCompare(t._meta.timestamp)>=0?[e,null]:[{value:Number(t.value),_meta:t._meta},t]}static create(){return new a}},M=y.create,c=class a extends s{encodeMutation(n,t,e){return {value:t,_meta:{timestamp:e}}}mergeMutation(n,t,e){return e&&e._meta.timestamp.localeCompare(t._meta.timestamp)>=0?[e,null]:[t,t]}static create(){return new a}},h=c.create;var u=class a extends o{name;fields;relations;constructor(n,t,e){super(),this.name=n,this.fields=t,this.relations=e??{};}encodeMutation(n,t,e){return Object.fromEntries(Object.entries(t).map(([r,i])=>[r,(this.fields[r]??this.relations[r]).encodeMutation("set",i,e)]))}mergeMutation(n,t,e){let r={};return [{value:{...(e==null?void 0:e.value)??{},...Object.fromEntries(Object.entries(t).map(([i,d])=>{let[v,m]=(this.fields[i]??this.relations[i]).mergeMutation(n,d,e==null?void 0:e.value[i]);return m&&(r[i]=m),[i,v]}))}},r]}setRelations(n){return new a(this.name,this.fields,n)}static create(n,t){return new a(n,t)}},A=u.create,l=class a extends o{entity;type;required;relationalColumn;foreignColumn;sourceEntity;constructor(n,t,e,r,i){super(),this.entity=n,this.type=t,this.required=i??false,this.relationalColumn=e,this.foreignColumn=r;}encodeMutation(n,t,e){if(n!=="set")throw new Error("Mutation type not implemented.");if(this.type==="many")throw new Error("Many not implemented.");return {value:t,_meta:{timestamp:e}}}mergeMutation(n,t,e){if(this.type==="many")throw new Error("Many not implemented.");return e&&e._meta.timestamp.localeCompare(t._meta.timestamp)>=0?[e,null]:[t,t]}static createOneFactory(){return (n,t,e)=>new a(n,"one",t,void 0,e??false)}static createManyFactory(){return (n,t,e)=>new a(n,"many",void 0,t,e??false)}},K=(a,n)=>({$type:"relations",objectName:a.name,relations:n({one:l.createOneFactory(),many:l.createManyFactory()})}),p=a=>Array.isArray(a.value)?a.value.map(n=>p(n)):typeof a.value!="object"?a.value:Object.fromEntries(Object.entries(a.value).map(([n,t])=>[n,p(t)])),E=a=>Object.fromEntries(Object.entries(a).flatMap(([n,t])=>{if(t.$type==="relations")return [];let e=t,r=Object.values(a).find(i=>i.$type==="relations"&&i.objectName===t.name);return r&&(e=e.setRelations(r.relations)),[[e.name,e]]}));exports.LiveNumber=y;exports.LiveObject=u;exports.LiveString=c;exports.LiveType=o;exports.Relation=l;exports.createRelations=K;exports.createSchema=E;exports.inferValue=p;exports.number=M;exports.object=A;exports.string=h;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export { C as ClientMessage, t as InferIndex, I as InferLiveObject, c as InferLiveObjectWithRelationalIds, r as InferLiveType, j as LiveNumber, e as LiveObject, L as LiveObjectAny, d as LiveObjectMutationInput, k as LiveString, p as LiveType, q as LiveTypeAny, l as LiveTypeMeta, g as MaterializedLiveObject, M as MaterializedLiveType, m as MutationType, R as Relation, S as Schema, b as ServerMessage, f as createRelations, h as createSchema, i as inferValue, n as number, o as object, s as string } from './index-sSVirsfN.cjs';
+import 'zod';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { C as ClientMessage, t as InferIndex, I as InferLiveObject, c as InferLiveObjectWithRelationalIds, r as InferLiveType, j as LiveNumber, e as LiveObject, L as LiveObjectAny, d as LiveObjectMutationInput, k as LiveString, p as LiveType, q as LiveTypeAny, l as LiveTypeMeta, g as MaterializedLiveObject, M as MaterializedLiveType, m as MutationType, R as Relation, S as Schema, b as ServerMessage, f as createRelations, h as createSchema, i as inferValue, n as number, o as object, s as string } from './index-sSVirsfN.js';
+import 'zod';

package/dist/index.js

@@ -0,0 +1 @@
+var o=class{_value;_meta;_encodeInput;_decodeInput};var T=class extends o{encodeMutation(n,t,e){throw new Error("Method not implemented.")}mergeMutation(n,t,e){throw new Error("Method not implemented.")}},s=class extends o{constructor(){super(),this.optional=this.optional.bind(this);}optional(){return new T}},y=class a extends s{encodeMutation(n,t,e){return {value:t,_meta:{timestamp:e}}}mergeMutation(n,t,e){return e&&e._meta.timestamp.localeCompare(t._meta.timestamp)>=0?[e,null]:[{value:Number(t.value),_meta:t._meta},t]}static create(){return new a}},M=y.create,c=class a extends s{encodeMutation(n,t,e){return {value:t,_meta:{timestamp:e}}}mergeMutation(n,t,e){return e&&e._meta.timestamp.localeCompare(t._meta.timestamp)>=0?[e,null]:[t,t]}static create(){return new a}},h=c.create;var u=class a extends o{name;fields;relations;constructor(n,t,e){super(),this.name=n,this.fields=t,this.relations=e??{};}encodeMutation(n,t,e){return Object.fromEntries(Object.entries(t).map(([r,i])=>[r,(this.fields[r]??this.relations[r]).encodeMutation("set",i,e)]))}mergeMutation(n,t,e){let r={};return [{value:{...(e==null?void 0:e.value)??{},...Object.fromEntries(Object.entries(t).map(([i,d])=>{let[v,m]=(this.fields[i]??this.relations[i]).mergeMutation(n,d,e==null?void 0:e.value[i]);return m&&(r[i]=m),[i,v]}))}},r]}setRelations(n){return new a(this.name,this.fields,n)}static create(n,t){return new a(n,t)}},A=u.create,l=class a extends o{entity;type;required;relationalColumn;foreignColumn;sourceEntity;constructor(n,t,e,r,i){super(),this.entity=n,this.type=t,this.required=i??false,this.relationalColumn=e,this.foreignColumn=r;}encodeMutation(n,t,e){if(n!=="set")throw new Error("Mutation type not implemented.");if(this.type==="many")throw new Error("Many not implemented.");return {value:t,_meta:{timestamp:e}}}mergeMutation(n,t,e){if(this.type==="many")throw new Error("Many not implemented.");return e&&e._meta.timestamp.localeCompare(t._meta.timestamp)>=0?[e,null]:[t,t]}static createOneFactory(){return (n,t,e)=>new a(n,"one",t,void 0,e??false)}static createManyFactory(){return (n,t,e)=>new a(n,"many",void 0,t,e??false)}},K=(a,n)=>({$type:"relations",objectName:a.name,relations:n({one:l.createOneFactory(),many:l.createManyFactory()})}),p=a=>Array.isArray(a.value)?a.value.map(n=>p(n)):typeof a.value!="object"?a.value:Object.fromEntries(Object.entries(a.value).map(([n,t])=>[n,p(t)])),E=a=>Object.fromEntries(Object.entries(a).flatMap(([n,t])=>{if(t.$type==="relations")return [];let e=t,r=Object.values(a).find(i=>i.$type==="relations"&&i.objectName===t.name);return r&&(e=e.setRelations(r.relations)),[[e.name,e]]}));export{y as LiveNumber,u as LiveObject,c as LiveString,o as LiveType,l as Relation,K as createRelations,E as createSchema,p as inferValue,M as number,A as object,h as string};

package/dist/server.cjs

@@ -0,0 +1 @@
+'use strict';var nanoid=require('nanoid'),zod=require('zod');var y=class{},S=class extends y{storage={};async updateSchema(e){console.log("Updating schema",e),this.storage=Object.entries(e).reduce((r,[s,i])=>(r[i.name]={},r),{});}async findById(e,r){var s;return (s=this.storage[e])==null?void 0:s[r]}async find(e,r){return this.storage[e]??{}}async upsert(e,r,s){return this.storage[e]??={},this.storage[e][r]=s,s}};var d=zod.z.string().nanoid(),v=zod.z.object({_id:d,type:zod.z.literal("SUBSCRIBE"),resource:zod.z.string()}),q=zod.z.object({_id:d,type:zod.z.literal("SYNC"),lastSyncedAt:zod.z.string().optional(),resources:zod.z.string().array().optional()}),R=zod.z.record(zod.z.object({value:zod.z.string().or(zod.z.number()).or(zod.z.boolean()).or(zod.z.date()),_meta:zod.z.object({timestamp:zod.z.string().optional()}).optional()})).superRefine((a,e)=>{a.id&&e.addIssue({code:zod.z.ZodIssueCode.custom,message:"Payload cannot have an id"});}),T=zod.z.object({_id:d,type:zod.z.literal("MUTATE"),resource:zod.z.string(),resourceId:zod.z.string(),payload:R}),b=zod.z.union([v,T,q]),x=zod.z.object({_id:d,type:zod.z.literal("SYNC"),resource:zod.z.string(),data:zod.z.record(R)}),j=zod.z.object({_id:d,type:zod.z.literal("REJECT"),resource:zod.z.string()});zod.z.union([T,x,j]);var _=a=>{let e={},r={};return a.subscribeToMutations(s=>{console.log("Mutation propagated:",s),Object.entries(r[s.resource]??{}).forEach(([i,p])=>{var o;(o=e[i])==null||o.send(JSON.stringify(s));});}),s=>{let i=nanoid.nanoid();e[i]=s,console.log("Client connected:",i),s.on("message",async p=>{try{console.log("Message received from the client:",p);let o=b.parse(JSON.parse(p.toString()));if(o.type==="SUBSCRIBE"){let{resource:n}=o;r[n]||(r[n]={}),r[n][i]={};}else if(o.type==="SYNC"){let{resources:n}=o,c=n??Object.keys(a.schema);console.log("Syncing resources:",c),await Promise.all(c.map(async u=>{let l=await a.handleRequest({req:{type:"FIND",resourceName:u,context:{}}});if(!l||!l.data)throw new Error("Invalid resource");s.send(JSON.stringify({_id:o._id,type:"SYNC",resource:u,data:Object.fromEntries(Object.entries(l.data??{}).map(([f,M])=>[f,M.value]))}));}));}else if(o.type==="MUTATE"){let{resource:n}=o;console.log("Received mutation from client:",o);try{let c=await a.handleRequest({req:{type:"SET",resourceName:n,payload:o.payload,context:{messageId:o._id},resourceId:o.resourceId}}).catch(u=>(console.error("Error handling mutation from the client:",u),null));(!c||!c.acceptedValues||Object.keys(c.acceptedValues).length===0)&&s.send(JSON.stringify({_id:o._id,type:"REJECT",resource:n}));}catch(c){s.send(JSON.stringify({_id:o._id,type:"REJECT",resource:n})),console.error("Error parsing mutation from the client:",c);}}}catch(o){console.error("Error handling message from the client:",o);}}),s.on("close",()=>{console.log("Connection closed",i),delete e[i];});}};var g=class a{routes;constructor(e){this.routes=e.routes;}static create(e){return new a(e)}},V=a=>g.create({...a}),h=class{shape;constructor(e){this.shape=e;}async handleFind(e){return {data:await e.db.find(e.req.resourceName,e.req.where),acceptedValues:null}}async handleSet(e){if(!e.req.payload)throw new Error("Payload is required");if(!e.req.resourceId)throw new Error("ResourceId is required");let r=await e.db.findById(e.req.resourceName,e.req.resourceId),[s,i]=this.shape.mergeMutation("set",e.req.payload,r);if(!i){if(!r)throw new Error("Mutation rejected");return {data:r,acceptedValues:null}}return {data:await e.db.upsert(e.req.resourceName,e.req.resourceId,s),acceptedValues:i}}async handleRequest(e){switch(e.req.type){case "FIND":return this.handleFind(e);case "SET":return this.handleSet(e);default:throw new Error("Invalid request type")}}},Z=()=>a=>new h(a),m=class a{router;storage;schema;mutationSubscriptions=new Set;constructor(e){this.router=e.router,this.storage=e.storage,this.schema=e.schema,this.storage.updateSchema(this.schema);}static create(e){return new a(e)}subscribeToMutations(e){return this.mutationSubscriptions.add(e),()=>{this.mutationSubscriptions.delete(e);}}async handleRequest(e){var s;let r=await((s=this.router.routes[e.req.resourceName])==null?void 0:s.handleRequest({req:e.req,db:this.storage}));return r&&e.req.type==="SET"&&r.acceptedValues&&Object.keys(r.acceptedValues).length>0&&this.mutationSubscriptions.forEach(i=>{i({_id:e.req.context.messageId??nanoid.nanoid(),type:"MUTATE",resource:e.req.resourceName,payload:r.acceptedValues??{},resourceId:e.req.resourceId});}),r}},k=m.create;exports.InMemoryStorage=S;exports.Route=h;exports.Router=g;exports.Server=m;exports.Storage=y;exports.routeFactory=Z;exports.router=V;exports.server=k;exports.webSocketAdapter=_;

package/dist/server.d.cts

@@ -0,0 +1,88 @@
+import { S as Schema, L as LiveObjectAny, M as MaterializedLiveType, a as MutationMessage } from './index-sSVirsfN.cjs';
+import WebSocket from 'ws';
+import 'zod';
+
+declare abstract class Storage {
+    abstract updateSchema(opts: Schema<any>): Promise<void>;
+    abstract findById<T extends LiveObjectAny>(resourceName: string, id: string): Promise<MaterializedLiveType<T> | undefined>;
+    abstract find<T extends LiveObjectAny>(resourceName: string, where?: Record<string, any>): Promise<Record<string, MaterializedLiveType<T>>>;
+    abstract upsert<T extends LiveObjectAny>(resourceName: string, resourceId: string, value: MaterializedLiveType<T>): Promise<MaterializedLiveType<T>>;
+}
+declare class InMemoryStorage extends Storage {
+    private storage;
+    updateSchema(opts: Schema<any>): Promise<void>;
+    findById<T extends LiveObjectAny>(resourceName: string, id: string): Promise<MaterializedLiveType<T> | undefined>;
+    find<T extends LiveObjectAny>(resourceName: string, where?: Record<string, any>): Promise<Record<string, MaterializedLiveType<T>>>;
+    upsert<T extends LiveObjectAny>(resourceName: string, resourceId: string, value: MaterializedLiveType<T>): Promise<MaterializedLiveType<T>>;
+}
+
+type Subscription = {
+    filters?: Record<string, any>;
+};
+declare const webSocketAdapter: (server: Server<AnyRouter>) => (ws: WebSocket) => void;
+
+type RequestBase = {
+    resourceName: string;
+    context: Record<string, any>;
+    where?: Record<string, any>;
+};
+type FindRequest = RequestBase & {
+    type: "FIND";
+};
+type SetRequest = RequestBase & {
+    type: "SET";
+    resourceId: string;
+    payload: Record<string, any>;
+};
+type Request = FindRequest | SetRequest;
+type RequestType = Request["type"];
+type RouteRecord = Record<string, Route<LiveObjectAny>>;
+declare class Router<TSchema extends Schema<any>, TRoutes extends RouteRecord> {
+    readonly routes: TRoutes;
+    private constructor();
+    static create<TSchema extends Schema<any>, TRoutes extends RouteRecord>(opts: {
+        routes: TRoutes;
+    }): Router<TSchema, TRoutes>;
+}
+declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<LiveObjectAny>>>(opts: {
+    schema: TSchema;
+    routes: TRoutes;
+}) => Router<Schema<any>, TRoutes>;
+type AnyRouter = Router<Schema<any>, RouteRecord>;
+type RouteResult<TShape extends LiveObjectAny> = {
+    data: MaterializedLiveType<TShape> | Record<string, MaterializedLiveType<TShape>>;
+    acceptedValues: Record<string, any> | null;
+};
+declare class Route<TShape extends LiveObjectAny> {
+    readonly shape: TShape;
+    constructor(shape: TShape);
+    private handleFind;
+    private handleSet;
+    handleRequest(opts: {
+        req: Request;
+        db: Storage;
+    }): Promise<RouteResult<TShape>>;
+}
+declare const routeFactory: () => <T extends LiveObjectAny>(shape: T) => Route<T>;
+type AnyRoute = Route<LiveObjectAny>;
+type ClientId = string;
+type MutationHandler = (mutation: MutationMessage) => void;
+declare class Server<TRouter extends AnyRouter> {
+    readonly router: TRouter;
+    readonly storage: Storage;
+    readonly schema: Schema<any>;
+    private mutationSubscriptions;
+    private constructor();
+    static create<TRouter extends AnyRouter>(opts: {
+        router: TRouter;
+        storage: Storage;
+        schema: Schema<any>;
+    }): Server<TRouter>;
+    subscribeToMutations(handler: MutationHandler): () => void;
+    handleRequest(opts: {
+        req: Request;
+    }): Promise<RouteResult<LiveObjectAny>>;
+}
+declare const server: typeof Server.create;
+
+export { type AnyRoute, type AnyRouter, type ClientId, type FindRequest, InMemoryStorage, type MutationHandler, type Request, type RequestType, Route, type RouteRecord, Router, Server, type SetRequest, Storage, type Subscription, routeFactory, router, server, webSocketAdapter };

package/dist/server.d.ts

@@ -0,0 +1,88 @@
+import { S as Schema, L as LiveObjectAny, M as MaterializedLiveType, a as MutationMessage } from './index-sSVirsfN.js';
+import WebSocket from 'ws';
+import 'zod';
+
+declare abstract class Storage {
+    abstract updateSchema(opts: Schema<any>): Promise<void>;
+    abstract findById<T extends LiveObjectAny>(resourceName: string, id: string): Promise<MaterializedLiveType<T> | undefined>;
+    abstract find<T extends LiveObjectAny>(resourceName: string, where?: Record<string, any>): Promise<Record<string, MaterializedLiveType<T>>>;
+    abstract upsert<T extends LiveObjectAny>(resourceName: string, resourceId: string, value: MaterializedLiveType<T>): Promise<MaterializedLiveType<T>>;
+}
+declare class InMemoryStorage extends Storage {
+    private storage;
+    updateSchema(opts: Schema<any>): Promise<void>;
+    findById<T extends LiveObjectAny>(resourceName: string, id: string): Promise<MaterializedLiveType<T> | undefined>;
+    find<T extends LiveObjectAny>(resourceName: string, where?: Record<string, any>): Promise<Record<string, MaterializedLiveType<T>>>;
+    upsert<T extends LiveObjectAny>(resourceName: string, resourceId: string, value: MaterializedLiveType<T>): Promise<MaterializedLiveType<T>>;
+}
+
+type Subscription = {
+    filters?: Record<string, any>;
+};
+declare const webSocketAdapter: (server: Server<AnyRouter>) => (ws: WebSocket) => void;
+
+type RequestBase = {
+    resourceName: string;
+    context: Record<string, any>;
+    where?: Record<string, any>;
+};
+type FindRequest = RequestBase & {
+    type: "FIND";
+};
+type SetRequest = RequestBase & {
+    type: "SET";
+    resourceId: string;
+    payload: Record<string, any>;
+};
+type Request = FindRequest | SetRequest;
+type RequestType = Request["type"];
+type RouteRecord = Record<string, Route<LiveObjectAny>>;
+declare class Router<TSchema extends Schema<any>, TRoutes extends RouteRecord> {
+    readonly routes: TRoutes;
+    private constructor();
+    static create<TSchema extends Schema<any>, TRoutes extends RouteRecord>(opts: {
+        routes: TRoutes;
+    }): Router<TSchema, TRoutes>;
+}
+declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<LiveObjectAny>>>(opts: {
+    schema: TSchema;
+    routes: TRoutes;
+}) => Router<Schema<any>, TRoutes>;
+type AnyRouter = Router<Schema<any>, RouteRecord>;
+type RouteResult<TShape extends LiveObjectAny> = {
+    data: MaterializedLiveType<TShape> | Record<string, MaterializedLiveType<TShape>>;
+    acceptedValues: Record<string, any> | null;
+};
+declare class Route<TShape extends LiveObjectAny> {
+    readonly shape: TShape;
+    constructor(shape: TShape);
+    private handleFind;
+    private handleSet;
+    handleRequest(opts: {
+        req: Request;
+        db: Storage;
+    }): Promise<RouteResult<TShape>>;
+}
+declare const routeFactory: () => <T extends LiveObjectAny>(shape: T) => Route<T>;
+type AnyRoute = Route<LiveObjectAny>;
+type ClientId = string;
+type MutationHandler = (mutation: MutationMessage) => void;
+declare class Server<TRouter extends AnyRouter> {
+    readonly router: TRouter;
+    readonly storage: Storage;
+    readonly schema: Schema<any>;
+    private mutationSubscriptions;
+    private constructor();
+    static create<TRouter extends AnyRouter>(opts: {
+        router: TRouter;
+        storage: Storage;
+        schema: Schema<any>;
+    }): Server<TRouter>;
+    subscribeToMutations(handler: MutationHandler): () => void;
+    handleRequest(opts: {
+        req: Request;
+    }): Promise<RouteResult<LiveObjectAny>>;
+}
+declare const server: typeof Server.create;
+
+export { type AnyRoute, type AnyRouter, type ClientId, type FindRequest, InMemoryStorage, type MutationHandler, type Request, type RequestType, Route, type RouteRecord, Router, Server, type SetRequest, Storage, type Subscription, routeFactory, router, server, webSocketAdapter };