@live-state/sync 0.0.3 → 0.0.4-beta.10

package/dist/server.d.cts

@@ -1,87 +1,49 @@
-import { z, ZodTypeAny } from 'zod';
-import { LiveObjectAny, Schema, MaterializedLiveType, IncludeClause, InferLiveObject, WhereClause, LiveObjectMutationInput } from './index.cjs';
+import { z } from 'zod';
+import { L as LiveObjectAny, W as WhereClause, S as Simplify, I as InferLiveObjectWithRelationalIds, M as MaterializedLiveType, a as Schema, b as IncludeClause, c as InferLiveObject, d as InferInsert, e as InferUpdate, f as Logger, g as LogLevel } from './index-COp5Ib0a.cjs';
+import * as z3 from 'zod/v3';
+import * as z4 from 'zod/v4/core';
 import { PostgresPool } from 'kysely';
 import { Application } from 'express-ws';
 
-declare const mutationSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"MUTATE">;
+declare const querySchema: z.ZodObject<{
     resource: z.ZodString;
-}, {
-    procedure: z.ZodString;
-    payload: z.ZodOptional<z.ZodAny>;
-}>, "strip", z.ZodTypeAny, {
-    procedure: string;
-    type: "MUTATE";
-    resource: string;
-    id?: string | undefined;
-    payload?: any;
-}, {
-    procedure: string;
-    type: "MUTATE";
-    resource: string;
-    id?: string | undefined;
-    payload?: any;
-}>, z.ZodObject<z.objectUtil.extendShape<{
+    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    include: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    lastSyncedAt: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type RawQueryRequest = z.infer<typeof querySchema>;
+declare const defaultMutationSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"MUTATE">;
     resource: z.ZodString;
-}, {
-    resourceId: z.ZodString;
-    payload: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+    resourceId: z.ZodOptional<z.ZodString>;
+    procedure: z.ZodEnum<{
+        INSERT: "INSERT";
+        UPDATE: "UPDATE";
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodObject<{
         value: z.ZodNullable<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>, z.ZodDate]>>;
         _meta: z.ZodOptional<z.ZodObject<{
             timestamp: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        }, "strip", z.ZodTypeAny, {
-            timestamp?: string | null | undefined;
-        }, {
-            timestamp?: string | null | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        value: string | number | boolean | Date | null;
-        _meta?: {
-            timestamp?: string | null | undefined;
-        } | undefined;
-    }, {
-        value: string | number | boolean | Date | null;
-        _meta?: {
-            timestamp?: string | null | undefined;
-        } | undefined;
-    }>>, Record<string, {
-        value: string | number | boolean | Date | null;
-        _meta?: {
-            timestamp?: string | null | undefined;
-        } | undefined;
-    }>, Record<string, {
-        value: string | number | boolean | Date | null;
-        _meta?: {
-            timestamp?: string | null | undefined;
-        } | undefined;
-    }>>;
-}>, "strip", z.ZodTypeAny, {
-    type: "MUTATE";
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DefaultMutation = Omit<z.infer<typeof defaultMutationSchema>, "resourceId"> & {
     resourceId: string;
-    resource: string;
-    payload: Record<string, {
-        value: string | number | boolean | Date | null;
-        _meta?: {
-            timestamp?: string | null | undefined;
-        } | undefined;
-    }>;
-    id?: string | undefined;
-}, {
-    type: "MUTATE";
-    resourceId: string;
-    resource: string;
-    payload: Record<string, {
-        value: string | number | boolean | Date | null;
-        _meta?: {
-            timestamp?: string | null | undefined;
-        } | undefined;
-    }>;
-    id?: string | undefined;
-}>]>;
-type RawMutationRequest = z.infer<typeof mutationSchema>;
+};
+
+type Awaitable<T> = T | Promise<T>;
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+/** biome-ignore-all lint/style/noNonNullAssertion: false positive */
 
 type RouteRecord = Record<string, AnyRoute>;
 declare class Router<TRoutes extends RouteRecord> {
@@ -91,11 +53,11 @@ declare class Router<TRoutes extends RouteRecord> {
         routes: TRoutes;
     }): Router<TRoutes>;
 }
-declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, AnyRoute>>(opts: {
+declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<any, any, any>>>(opts: {
     schema: TSchema;
     routes: TRoutes;
 }) => Router<TRoutes>;
-type AnyRouter = Router<RouteRecord>;
+type AnyRouter = Router<any>;
 type QueryResult<TShape extends LiveObjectAny> = {
     data: Record<string, MaterializedLiveType<TShape>>;
 };
@@ -103,50 +65,56 @@ type MutationResult<TShape extends LiveObjectAny> = {
     data: MaterializedLiveType<TShape>;
     acceptedValues: Record<string, any> | null;
 };
-type RequestHandler<TInput, TResult, TSchema extends Schema<any> = Schema<any>> = (opts: {
-    req: ParsedRequest<TInput>;
-    db: Storage;
-    schema: TSchema;
-}) => Promise<TResult>;
-type Mutation<TInputValidator extends ZodTypeAny, // TODO use StandardSchema instead
-THandler extends RequestHandler<z.infer<TInputValidator>, any, any>> = {
+type Mutation<TInputValidator extends z3.ZodTypeAny | z4.$ZodType, // TODO use StandardSchema instead
+TOutput> = {
     inputValidator: TInputValidator;
-    handler: THandler;
+    handler: (opts: {
+        req: MutationRequest<z.infer<TInputValidator>>;
+        db: Storage;
+    }) => TOutput;
+};
+declare const mutationCreator: <TInputValidator extends z3.ZodTypeAny | z4.$ZodType>(validator?: TInputValidator) => {
+    handler: <THandler extends Mutation<TInputValidator, any>["handler"]>(handler: THandler) => Mutation<TInputValidator, ReturnType<THandler>>;
 };
-declare const mutationCreator: <TInputValidator extends ZodTypeAny>(validator?: TInputValidator) => {
-    handler: <THandler extends RequestHandler<z.infer<TInputValidator>, any, any>>(handler: THandler) => Mutation<TInputValidator, THandler>;
+type ReadAuthorizationHandler<TShape extends LiveObjectAny> = (opts: {
+    ctx: BaseRequest["context"];
+}) => WhereClause<TShape> | boolean;
+type MutationAuthorizationHandler<TShape extends LiveObjectAny> = (opts: {
+    ctx: BaseRequest["context"];
+    value: Simplify<InferLiveObjectWithRelationalIds<TShape>>;
+}) => WhereClause<TShape> | boolean;
+type Authorization<TShape extends LiveObjectAny> = {
+    read?: ReadAuthorizationHandler<TShape>;
+    insert?: MutationAuthorizationHandler<TShape>;
+    update?: {
+        preMutation?: MutationAuthorizationHandler<TShape>;
+        postMutation?: MutationAuthorizationHandler<TShape>;
+    };
 };
-declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, RequestHandler<any, any>>>> {
-    readonly _resourceSchema: TResourceSchema;
-    readonly resourceName: TResourceSchema["name"];
+declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>> {
+    readonly resourceSchema: TResourceSchema;
     readonly middlewares: Set<TMiddleware>;
     readonly customMutations: TCustomMutations;
-    constructor(resourceName: TResourceSchema["name"], customMutations?: TCustomMutations);
-    private handleFind;
-    private handleSet;
-    handleRequest(opts: {
-        req: ParsedRequest;
-        db: Storage;
-        schema: Schema<any>;
-    }): Promise<any>;
+    readonly authorization?: Authorization<TResourceSchema>;
+    constructor(resourceSchema: TResourceSchema, customMutations?: TCustomMutations, authorization?: Authorization<TResourceSchema>);
     use(...middlewares: TMiddleware[]): this;
-    withMutations<T extends Record<string, Mutation<any, RequestHandler<any, any>>>>(mutationFactory: (opts: {
+    withMutations<T extends Record<string, Mutation<any, any>>>(mutationFactory: (opts: {
         mutation: typeof mutationCreator;
     }) => T): Route<TResourceSchema, TMiddleware, T>;
+    private handleSet;
+    private wrapInMiddlewares;
 }
 declare class RouteFactory {
     private middlewares;
     private constructor();
-    createBasicRoute<T extends LiveObjectAny>(shape: T): Route<T, Middleware<any>, Record<string, never>>;
+    collectionRoute<T extends LiveObjectAny>(shape: T, authorization?: Authorization<T>): Route<T, Middleware<any>, Record<string, never>>;
     use(...middlewares: Middleware<any>[]): RouteFactory;
     static create(): RouteFactory;
 }
 declare const routeFactory: typeof RouteFactory.create;
 type AnyRoute = Route<LiveObjectAny, Middleware<any>, Record<string, any>>;
 
-type Simplify<T> = T extends Record<string, unknown> ? {
-    [K in keyof T]: Simplify<T[K]>;
-} : T;
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 
 declare abstract class Storage {
     abstract findOne<T extends LiveObjectAny>(resource: T, id: string, options?: {
@@ -156,12 +124,21 @@ declare abstract class Storage {
         where?: WhereClause<T>;
         include?: IncludeClause<T>;
     }): Promise<Record<string, InferLiveObject<T>>>;
-    insert<T extends LiveObjectAny>(resource: T, value: Simplify<LiveObjectMutationInput<T>>): Promise<InferLiveObject<T>>;
-    update<T extends LiveObjectAny>(resource: T, resourceId: string, value: LiveObjectMutationInput<T>): Promise<InferLiveObject<T>>;
+    insert<T extends LiveObjectAny>(resource: T, value: Simplify<InferInsert<T>>): Promise<InferLiveObject<T>>;
+    update<T extends LiveObjectAny>(resource: T, resourceId: string, value: InferUpdate<T>): Promise<InferLiveObject<T>>;
+    abstract transaction<T>(fn: (opts: {
+        trx: Storage;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }) => Promise<T>): Promise<T>;
 }
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+
 declare class SQLStorage extends Storage {
     private db;
     private schema?;
+    private logger?;
     constructor(pool: PostgresPool);
     findOne<T extends LiveObjectAny>(resource: T, id: string, options?: {
         include?: IncludeClause<T>;
@@ -169,37 +146,51 @@ declare class SQLStorage extends Storage {
     find<T extends LiveObjectAny>(resource: T, options?: {
         where?: WhereClause<T>;
         include?: IncludeClause<T>;
+        limit?: number;
+        sort?: {
+            key: string;
+            direction: "asc" | "desc";
+        }[];
     }): Promise<Record<string, InferLiveObject<T>>>;
+    transaction<T>(fn: (opts: {
+        trx: Storage;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }) => Promise<T>): Promise<T>;
     private convertToMaterializedLiveType;
-    private applyWhere;
-    private applyInclude;
+    private isKyselyLike;
 }
 
 declare const expressAdapter: (app: Application, server: Server<AnyRouter>, options?: {
     basePath?: string;
 }) => void;
 
-type ParsedRequest<TInput = any> = {
+/** biome-ignore-all lint/suspicious/noExplicitAny: any's are actually used correctly */
+
+interface BaseRequest {
     headers: Record<string, string>;
     cookies: Record<string, string>;
-    query: Record<string, string>;
-    resourceName: string;
-    procedure?: string;
+    queryParams: Record<string, string>;
     context: Record<string, any>;
-    where?: Record<string, any>;
-    include?: Record<string, any>;
-    type: "QUERY" | "MUTATE";
+}
+interface QueryRequest extends BaseRequest, RawQueryRequest {
+    type: "QUERY";
+}
+interface MutationRequest<TInput = any> extends BaseRequest {
+    type: "MUTATE";
+    input: TInput;
+    resource: string;
     resourceId?: string;
-    input?: TInput;
-};
-type ContextProvider = (req: Pick<ParsedRequest, "headers" | "cookies" | "query"> & {
+    procedure: string;
+}
+type Request = QueryRequest | MutationRequest;
+type ContextProvider = (req: Omit<BaseRequest, "context"> & {
     transport: "HTTP" | "WEBSOCKET";
 }) => Record<string, any>;
-type RequestType = ParsedRequest["type"];
-type MutationHandler = (mutation: RawMutationRequest) => void;
-type NextFunction<T> = (req: ParsedRequest) => Promise<T> | T;
+type MutationHandler = (mutation: DefaultMutation) => void;
+type NextFunction<O, R = Request> = (req: R) => Awaitable<O>;
 type Middleware<T = any> = (opts: {
-    req: ParsedRequest;
+    req: Request;
     next: NextFunction<T>;
 }) => ReturnType<NextFunction<T>>;
 declare class Server<TRouter extends AnyRouter> {
@@ -207,6 +198,7 @@ declare class Server<TRouter extends AnyRouter> {
     readonly storage: Storage;
     readonly schema: Schema<any>;
     readonly middlewares: Set<Middleware<any>>;
+    readonly logger: Logger;
     contextProvider?: ContextProvider;
     private mutationSubscriptions;
     private constructor();
@@ -216,14 +208,19 @@ declare class Server<TRouter extends AnyRouter> {
         schema: Schema<any>;
         middlewares?: Middleware<any>[];
         contextProvider?: ContextProvider;
+        logLevel?: LogLevel;
     }): Server<TRouter>;
     subscribeToMutations(handler: MutationHandler): () => void;
-    handleRequest(opts: {
-        req: ParsedRequest;
+    handleQuery(opts: {
+        req: QueryRequest;
+    }): Promise<QueryResult<any>>;
+    handleMutation(opts: {
+        req: MutationRequest;
     }): Promise<any>;
     use(middleware: Middleware<any>): this;
     context(contextProvider: ContextProvider): this;
+    private wrapInMiddlewares;
 }
 declare const server: typeof Server.create;
 
-export { type AnyRoute, type AnyRouter, type ContextProvider, type Middleware, type Mutation, type MutationHandler, type MutationResult, type NextFunction, type ParsedRequest, type QueryResult, type RequestHandler, type RequestType, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, Storage, expressAdapter, routeFactory, router, server };
+export { type AnyRoute, type AnyRouter, type Authorization, type BaseRequest, type ContextProvider, type Middleware, type Mutation, type MutationAuthorizationHandler, type MutationHandler, type MutationRequest, type MutationResult, type NextFunction, type QueryRequest, type QueryResult, type ReadAuthorizationHandler, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, Storage, expressAdapter, routeFactory, router, server };