@syncular/client 0.0.6-95 → 0.1.0

package/src/sync.ts

@@ -1,170 +0,0 @@
-import type {
-  ColumnCodecDialect,
-  ColumnCodecSource,
-  ScopeDefinition,
-  ScopeValue,
-  ScopeValuesFromPatterns,
-  SyncSubscriptionRequest,
-} from '@syncular/core';
-import {
-  type CreateClientHandlerOptions,
-  createClientHandler,
-} from './handlers/create-handler';
-import type { ClientTableHandler } from './handlers/types';
-import type { SyncClientDb } from './schema';
-
-type ClientSyncSubscription<ScopeDefs extends readonly ScopeDefinition[]> =
-  Omit<SyncSubscriptionRequest, 'cursor' | 'table' | 'scopes'> & {
-    table: string;
-    scopes?: ScopeValuesFromPatterns<ScopeDefs>;
-  };
-
-type SharedTableName<DB extends SyncClientDb> = keyof DB & string;
-
-export type ClientSyncHandlerOptionsForTable<
-  DB extends SyncClientDb,
-  TableName extends SharedTableName<DB>,
-  ScopeDefs extends readonly ScopeDefinition[],
-  Identity,
-> = Omit<
-  CreateClientHandlerOptions<DB, TableName, ScopeDefs>,
-  'codecs' | 'codecDialect' | 'subscribe'
-> & {
-  codecs?: ColumnCodecSource;
-  codecDialect?: ColumnCodecDialect;
-  subscribe?:
-    | ClientSyncSubscription<ScopeDefs>
-    | ClientSyncSubscription<ScopeDefs>[]
-    | null
-    | ((args: {
-        identity: Identity;
-      }) =>
-        | ClientSyncSubscription<ScopeDefs>
-        | ClientSyncSubscription<ScopeDefs>[]
-        | null);
-};
-
-export interface ClientSyncConfig<
-  DB extends SyncClientDb = SyncClientDb,
-  Identity = { actorId: string },
-> {
-  handlers: ClientTableHandler<DB>[];
-  subscriptions(
-    identity: Identity
-  ): Array<Omit<SyncSubscriptionRequest, 'cursor'>>;
-}
-
-export interface DefineClientSyncOptions {
-  codecs?: ColumnCodecSource;
-  codecDialect?: ColumnCodecDialect;
-}
-
-export interface ClientSyncBuilder<
-  DB extends SyncClientDb,
-  ScopeDefs extends readonly ScopeDefinition[],
-  Identity,
-> extends ClientSyncConfig<DB, Identity> {
-  addHandler<TableName extends SharedTableName<DB>>(
-    options: ClientSyncHandlerOptionsForTable<
-      DB,
-      TableName,
-      ScopeDefs,
-      Identity
-    >
-  ): this;
-}
-
-export function defineClientSync<
-  DB extends SyncClientDb,
-  ScopeDefs extends readonly ScopeDefinition[],
-  Identity,
->(
-  options: DefineClientSyncOptions
-): ClientSyncBuilder<DB, ScopeDefs, Identity> {
-  const handlers: ClientTableHandler<DB>[] = [];
-  const registeredTables = new Set<string>();
-  const subscriptionsByTable = new Map<
-    string,
-    ClientSyncHandlerOptionsForTable<
-      DB,
-      SharedTableName<DB>,
-      ScopeDefs,
-      Identity
-    >['subscribe']
-  >();
-
-  const toScopeValues = (
-    value: ScopeValuesFromPatterns<ScopeDefs> | undefined
-  ): Record<string, ScopeValue> => {
-    const result: Record<string, ScopeValue> = {};
-    for (const [key, scopeValue] of Object.entries(
-      (value ?? {}) as Record<string, ScopeValue | undefined>
-    )) {
-      if (scopeValue === undefined) continue;
-      result[key] = scopeValue;
-    }
-    return result;
-  };
-
-  const sync: ClientSyncBuilder<DB, ScopeDefs, Identity> = {
-    handlers,
-    addHandler<TableName extends SharedTableName<DB>>(
-      handlerOptions: ClientSyncHandlerOptionsForTable<
-        DB,
-        TableName,
-        ScopeDefs,
-        Identity
-      >
-    ) {
-      if (registeredTables.has(handlerOptions.table)) {
-        throw new Error(
-          `Client table handler already registered: ${handlerOptions.table}`
-        );
-      }
-
-      handlers.push(
-        createClientHandler({
-          ...handlerOptions,
-          subscribe: false,
-          codecs: options.codecs,
-          codecDialect: options.codecDialect,
-        })
-      );
-      subscriptionsByTable.set(
-        handlerOptions.table,
-        handlerOptions.subscribe as ClientSyncHandlerOptionsForTable<
-          DB,
-          SharedTableName<DB>,
-          ScopeDefs,
-          Identity
-        >['subscribe']
-      );
-      registeredTables.add(handlerOptions.table);
-      return sync;
-    },
-    subscriptions(
-      identity: Identity
-    ): Array<Omit<SyncSubscriptionRequest, 'cursor'>> {
-      const resolved: Array<Omit<SyncSubscriptionRequest, 'cursor'>> = [];
-      for (const [table, subscribe] of subscriptionsByTable.entries()) {
-        if (!subscribe) continue;
-        const value =
-          typeof subscribe === 'function' ? subscribe({ identity }) : subscribe;
-        if (!value) continue;
-        const entries = Array.isArray(value) ? value : [value];
-        for (const entry of entries) {
-          resolved.push({
-            id: entry.id,
-            table: entry.table ?? table,
-            scopes: toScopeValues(entry.scopes),
-            params: entry.params,
-            bootstrapState: entry.bootstrapState,
-          });
-        }
-      }
-      return resolved;
-    },
-  };
-
-  return sync;
-}

package/src/utils/id.ts

@@ -1,55 +0,0 @@
-/**
- * ID generation utilities
- */
-
-/**
- * Generate a random UUID v4
- */
-export function randomUUID(): string {
-  // Use crypto.randomUUID if available (modern browsers, Node, Bun)
-  if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-
-  // Fallback implementation
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === 'x' ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-}
-
-/**
- * Build a stable state id from meaningful segments.
- * Empty/undefined segments are ignored.
- */
-export function buildStateId(
-  ...segments: Array<string | null | undefined>
-): string {
-  const normalized = segments
-    .map((segment) => segment?.trim())
-    .filter((segment): segment is string => !!segment && segment.length > 0);
-
-  if (normalized.length === 0) return 'default';
-  return normalized.join(':');
-}
-
-/**
- * Create a deterministic fingerprint string for scope values.
- */
-export function createScopeFingerprint(
-  scopes: Record<string, string | string[]>
-): string {
-  const entries = Object.entries(scopes)
-    .map(([key, value]) => {
-      const encodedValues = (Array.isArray(value) ? [...value] : [value])
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0)
-        .sort();
-
-      return `${key}:${encodedValues.join('|')}`;
-    })
-    .sort();
-
-  return entries.join(';');
-}