@evolu/common 6.0.1-preview.3 → 6.0.1-preview.5

package/dist/src/Evolu/Schema.js

@@ -1,86 +1,27 @@
 import { pack } from "msgpackr";
+import { assert } from "../Assert.js";
 import { mapObject, objectToEntries } from "../Object.js";
 import { err, ok } from "../Result.js";
 import { SqliteBoolean } from "../Sqlite.js";
-import { brand, createTypeErrorFormatter, DateIsoString, EvoluType, nullableToOptional, nullOr, object, omit, optional, record, Unknown, } from "../Type.js";
+import { brand, createTypeErrorFormatter, DateIsoString, nullableToOptional, nullOr, object, omit, optional, } from "../Type.js";
+import { DbSchema } from "./Db.js";
 import { createIndexes } from "./Kysely.js";
-import { Base64Url256, } from "./Protocol.js";
-export const DefaultColumns = object({
-    createdAt: DateIsoString,
-    updatedAt: DateIsoString,
-    isDeleted: nullOr(SqliteBoolean),
-});
-const isDefaultColumnName = (value) => value === "createdAt" || value === "updatedAt" || value === "isDeleted";
-/**
- * Valid {@link EvoluSchema}.
- *
- * - Table and column names must be Base64Url strings.
- * - Each table must include an `id` column of type {@link Id}.
- * - Default column names (`createdAt`, `updatedAt`, `isDeleted`) are not allowed.
- */
-export const ValidEvoluSchema = brand("ValidEvoluSchema", record(Base64Url256, object({ id: EvoluType }, record(Base64Url256, Unknown))), (value) => {
-    for (const tableName in value) {
-        for (const columnName in value[tableName]) {
-            if (isDefaultColumnName(columnName)) {
-                return err({
-                    type: "ValidEvoluSchema",
-                    value,
-                    reason: {
-                        kind: "DefaultColumnError",
-                        tableName,
-                        columnName,
-                    },
-                });
-            }
-        }
-    }
-    return ok(value);
-});
-/**
- * Asserts that the given value is {@link ValidEvoluSchema}.
- *
- * Throws an error if the value is not a valid Evolu schema.
- */
-export const assertValidEvoluSchema = (value) => {
-    const validEvoluSchema = ValidEvoluSchema.fromUnknown(value);
-    if (!validEvoluSchema.ok) {
-        const message = formatValidEvoluSchemaError(validEvoluSchema.error);
-        throw new Error(`Invalid Evolu schema: ${message}`);
-    }
-    return validEvoluSchema.value;
-};
-const formatValidEvoluSchemaError = (error) => {
-    if (error.type === "Record") {
-        if (error.reason.kind === "Key") {
-            return `The table "${error.reason.key}" has invalid name. A table name must be Base64Url256 string (A-Z, a-z, 0-9, -, _).`;
-        }
-        if (error.reason.kind === "Value" &&
-            error.reason.error.reason.kind === "Props" &&
-            error.reason.error.reason.errors.id?.type === "EvoluType") {
-            return `The table "${error.reason.key}" has invalid ID column. Check examples.`;
-        }
-        if (error.reason.kind === "Value" &&
-            error.reason.error.reason.kind === "IndexKey") {
-            return `The table "${error.reason.key}" has invalid column name "${error.reason.error.reason.key}". A column name must be Base64Url256 string (A-Z, a-z, 0-9, -, _).`;
-        }
-    }
-    if (error.type === "ValidEvoluSchema") {
-        return `The table "${error.reason.tableName}" uses reserved column name "${error.reason.columnName}". Reserved column names are: createdAt, updatedAt, isDeleted.`;
-    }
-    return JSON.stringify(error, null, 2);
-};
-export const validEvoluSchemaToDbSchema = (validEvoluSchema, indexes) => {
-    const tables = objectToEntries(validEvoluSchema).map(([tableName, table]) => ({
+export const evoluSchemaToDbSchema = (schema, indexes) => {
+    const tables = objectToEntries(schema).map(([tableName, table]) => ({
         name: tableName,
         columns: objectToEntries(table)
             .filter(([k]) => k !== "id")
             .map(([k]) => k),
     }));
-    return {
-        tables,
-        indexes: createIndexes(indexes),
-    };
+    const dbSchema = { tables, indexes: createIndexes(indexes) };
+    assert(DbSchema.is(dbSchema), "Invalid EvoluSchema: Table and column names must use only characters A-Za-z0-9_- and be at most 256 characters long.");
+    return dbSchema;
 };
+export const DefaultColumns = object({
+    createdAt: DateIsoString,
+    updatedAt: DateIsoString,
+    isDeleted: nullOr(SqliteBoolean),
+});
 /**
  * Evolu has to limit the maximum mutation size. Otherwise, sync couldn't use
  * the {@link maxProtocolMessageRangesSize}. The max size is 640KB in bytes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/common",
-  "version": "6.0.1-preview.3",
+  "version": "6.0.1-preview.5",
   "description": "TypeScript library and local-first framework",
   "keywords": [
     "evolu",

package/src/Crypto.ts

@@ -189,3 +189,16 @@ export const padmePaddedLength = (length: NonNegativeInt): NonNegativeInt => {
 export const padmePaddingLength = (length: NonNegativeInt): NonNegativeInt => {
   return (padmePaddedLength(length) - length) as NonNegativeInt;
 };
+
+/**
+ * Performs a timing-safe comparison of two Uint8Arrays. Returns true if they
+ * are equal, false otherwise. Takes constant time regardless of where the
+ * arrays differ.
+ *
+ * @see https://nodejs.org/api/crypto.html#cryptotimingsafeequala-b
+ */
+export type TimingSafeEqual = (a: Uint8Array, b: Uint8Array) => boolean;
+
+export interface TimingSafeEqualDep {
+  readonly timingSafeEqual: TimingSafeEqual;
+}

package/src/Evolu/Db.ts

@@ -34,7 +34,7 @@ import {
   SqliteValue,
 } from "../Sqlite.js";
 import { TimeDep } from "../Time.js";
-import { Id, Mnemonic, object, SimpleName, String } from "../Type.js";
+import { array, Id, Mnemonic, object, SimpleName, String } from "../Type.js";
 import {
   createInitializedWorker,
   Worker,
@@ -97,19 +97,21 @@ import {
   timestampToTimestampString,
 } from "./Timestamp.js";
 
-export interface DbSchema {
-  readonly tables: ReadonlyArray<DbTable>;
-  readonly indexes: ReadonlyArray<DbIndex>;
-}
-
-export interface DbTable {
-  readonly name: Base64Url256;
-  readonly columns: ReadonlyArray<Base64Url256>;
-}
+export const DbTable = object({
+  name: Base64Url256,
+  columns: array(Base64Url256),
+});
+export type DbTable = typeof DbTable.Type;
 
 export const DbIndex = object({ name: String, sql: String });
 export type DbIndex = typeof DbIndex.Type;
 
+export const DbSchema = object({
+  tables: array(DbTable),
+  indexes: array(DbIndex),
+});
+export type DbSchema = typeof DbSchema.Type;
+
 export type DbWorker = Worker<DbWorkerInput, DbWorkerOutput>;
 
 export type CreateDbWorker = (name: SimpleName) => DbWorker;
@@ -803,6 +805,8 @@ const initializeDb =
         strict;
       `,
 
+      // Index for reading database changes by owner and timestamp.
+      // Timestamp always corresponds to a DbChange.
       sql`
         create index evolu_history_ownerId_timestamp on evolu_history (
           "ownerId",
@@ -1189,7 +1193,6 @@ const createClientStorage =
 
       writeMessages: (_ownerId, messages) => {
         // TODO: Get owner by _ownerId when we support more.
-        // Use ownerId!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         const owner = deps.ownerRowRef.get();
         const decodedAndDecryptedMessages: Array<CrdtMessage> = [];
 

package/src/Evolu/Evolu.ts

@@ -1,5 +1,5 @@
 import { isNonEmptyArray, isNonEmptyReadonlyArray } from "../Array.js";
-import { assertNonEmptyArray } from "../Assert.js";
+import { assert, assertNonEmptyArray } from "../Assert.js";
 import { createCallbacks } from "../Callbacks.js";
 import { ConsoleDep } from "../Console.js";
 import { SymmetricCryptoDecryptError } from "../Crypto.js";
@@ -44,9 +44,9 @@ import {
   SubscribedQueries,
 } from "./Query.js";
 import {
-  assertValidEvoluSchema,
   CreateQuery,
   EvoluSchema,
+  evoluSchemaToDbSchema,
   insertable,
   Mutation,
   MutationKind,
@@ -54,7 +54,7 @@ import {
   MutationOptions,
   updateable,
   upsertable,
-  validEvoluSchemaToDbSchema,
+  ValidateSchema,
   ValidMutationSize,
   ValidMutationSizeError,
 } from "./Schema.js";
@@ -431,9 +431,7 @@ let tabId: Id | null = null;
 export const createEvolu =
   (deps: EvoluDeps) =>
   <S extends EvoluSchema>(
-    // TODO: Validate missing Id, unsupported types, used default types via TS types
-    // with type errors messages as we had it in the old Evolu.
-    schema: S,
+    schema: ValidateSchema<S> extends never ? S : ValidateSchema<S>,
     partialConfig: Partial<EvoluConfigWithInitialData<S>> = {},
   ): Evolu<S> => {
     const config = { ...defaultConfig, ...partialConfig };
@@ -441,11 +439,14 @@ export const createEvolu =
     let evolu = evoluInstances.get(config.name);
 
     if (evolu == null) {
-      evolu = createEvoluInstance(deps)(schema, config as IntentionalNever);
+      evolu = createEvoluInstance(deps)(
+        schema as EvoluSchema,
+        config as IntentionalNever,
+      );
       evoluInstances.set(config.name, evolu);
     } else {
       // Hot reloading. Note that indexes are intentionally omitted.
-      evolu.ensureSchema(schema);
+      evolu.ensureSchema(schema as EvoluSchema);
     }
 
     return evolu as IntentionalNever;
@@ -554,10 +555,7 @@ const createEvoluInstance =
       }
     });
 
-    const dbSchema = validEvoluSchemaToDbSchema(
-      assertValidEvoluSchema(schema),
-      indexes,
-    );
+    const dbSchema = evoluSchemaToDbSchema(schema, indexes);
 
     const mutationTypesCache = new Map<
       MutationKind,
@@ -592,21 +590,17 @@ const createEvoluInstance =
     if (initialData)
       initialData({
         insert: (table, props) => {
-          const Type = getMutationType(table, "insert");
           const id = createId(deps);
+          const values = getMutationType(table, "insert").fromUnknown(props);
 
-          const result = Type.fromUnknown(props);
-
-          if (result.ok) {
-            initialDataDbChanges.push({
-              id,
-              table,
-              values: result.value,
-            } as unknown as DbChange);
+          if (values.ok) {
+            const dbChange = { table, id, values: values.value };
+            assertValidDbChange(dbChange);
+            initialDataDbChanges.push(dbChange);
             return ok({ id });
           }
 
-          return result;
+          return values;
         },
       });
 
@@ -654,14 +648,14 @@ const createEvoluInstance =
           } else {
             // Remove `id` from values.
             const { id: _id, ...values } = result.value;
-            // EvoluSchema Types ensure valid types.
-            const change = { table, id, values } as unknown as DbChange;
-            mutateMicrotaskQueue.push([change, options?.onComplete]);
+            const dbChange = { table, id, values };
+            assertValidDbChange(dbChange);
+            mutateMicrotaskQueue.push([dbChange, options?.onComplete]);
           }
 
           if (mutateMicrotaskQueue.length === 1)
             queueMicrotask(() => {
-              const changes = [];
+              const changes: Array<DbChange> = [];
               const onCompletes = [];
 
               for (const [change, onComplete] of mutateMicrotaskQueue) {
@@ -807,6 +801,7 @@ const createEvoluInstance =
         const onCompleteId = callbacks.register(() => {
           resolve();
         });
+
         dbWorker.postMessage({
           type: "reset",
           onCompleteId,
@@ -822,11 +817,8 @@ const createEvoluInstance =
 
       ensureSchema: (schema) => {
         mutationTypesCache.clear();
-        const validSchema = assertValidEvoluSchema(schema);
-        dbWorker.postMessage({
-          type: "ensureDbSchema",
-          dbSchema: validEvoluSchemaToDbSchema(validSchema),
-        });
+        const dbSchema = evoluSchemaToDbSchema(schema);
+        dbWorker.postMessage({ type: "ensureDbSchema", dbSchema });
       },
 
       exportDatabase: () => {
@@ -945,3 +937,14 @@ const createLoadingPromises = (
 
   return loadingPromises;
 };
+
+const assertValidDbChange: (dbChange: {
+  table: string;
+  id: Id;
+  values: unknown;
+}) => asserts dbChange is DbChange = (dbChange) => {
+  assert(
+    DbChange.is(dbChange),
+    `Failed to create DbChange for table "${dbChange.table}". If you see this message, you either disabled EvoluSchema validation or Evolu has a bug - please report it.`,
+  );
+};

package/src/Evolu/Protocol.ts

@@ -144,7 +144,7 @@ import {
 } from "../Crypto.js";
 import { eqArrayNumber } from "../Eq.js";
 import { computeBalancedBuckets } from "../Number.js";
-import { objectToEntries, ReadonlyRecord } from "../Object.js";
+import { objectToEntries } from "../Object.js";
 import { err, ok, Result } from "../Result.js";
 import { SqliteValue } from "../Sqlite.js";
 import {
@@ -157,7 +157,9 @@ import {
   NanoId,
   NonNegativeInt,
   Number,
+  object,
   PositiveInt,
+  record,
 } from "../Type.js";
 import { Brand, Predicate } from "../Types.js";
 import {
@@ -293,15 +295,23 @@ export interface CrdtMessage {
   readonly change: DbChange;
 }
 
+/**
+ * Base64Url string with maximum length of 256 characters. Encoding strings as
+ * Base64UrlString saves up to 25% in size compared to regular strings.
+ */
+export const Base64Url256 = maxLength(256)(Base64Url);
+export type Base64Url256 = typeof Base64Url256.Type;
+
 /**
  * A DbChange is a change to a table row. Together with a unique
  * {@link Timestamp}, it forms a {@link CrdtMessage}.
  */
-export interface DbChange {
-  readonly table: Base64Url256;
-  readonly id: Id;
-  readonly values: ReadonlyRecord<Base64Url256, SqliteValue>;
-}
+export const DbChange = object({
+  table: Base64Url256,
+  id: Id,
+  values: record(Base64Url256, SqliteValue),
+});
+export type DbChange = typeof DbChange.Type;
 
 export const RangeType = {
   Fingerprint: 1,
@@ -1434,13 +1444,6 @@ export const ownerIdToBinaryOwnerId = (ownerId: OwnerId): BinaryOwnerId =>
 export const binaryOwnerIdToOwnerId = (binaryOwnerId: BinaryOwnerId): OwnerId =>
   decodeOwnerId(createBuffer(binaryOwnerId));
 
-/**
- * Base64Url string with maximum length of 256 characters. Encoding strings as
- * Base64UrlString saves up to 25% in size compared to regular strings.
- */
-export const Base64Url256 = maxLength(256)(Base64Url);
-export type Base64Url256 = typeof Base64Url256.Type;
-
 /**
  * Union type for all variants of Base64Url strings with limited length. All
  * these types use Base64Url alphabet and are < 256 characters.

package/src/Evolu/Relay.ts

@@ -1,6 +1,6 @@
 import { isNonEmptyReadonlyArray } from "../Array.js";
 import { ConsoleConfig } from "../Console.js";
-import { eqArrayNumber } from "../Eq.js";
+import { TimingSafeEqualDep } from "../Crypto.js";
 import { ok, Result } from "../Result.js";
 import { sql, SqliteError } from "../Sqlite.js";
 import { SimpleName } from "../Type.js";
@@ -19,8 +19,10 @@ export interface RelayConfig extends ConsoleConfig {
   readonly name?: SimpleName;
 }
 
+export type RelaySqliteStorageDeps = SqliteStorageDeps & TimingSafeEqualDep;
+
 export const createRelayStorage =
-  (deps: SqliteStorageDeps) =>
+  (deps: RelaySqliteStorageDeps) =>
   (options: CreateSqliteStorageBaseOptions): Result<Storage, SqliteError> => {
     const sqliteStorageBase = createSqliteStorageBase(deps)(options);
     if (!sqliteStorageBase.ok) return sqliteStorageBase;
@@ -87,7 +89,7 @@ export const createRelayStorage =
           return true;
         }
 
-        return eqArrayNumber(rows[0].writeKey, writeKey);
+        return deps.timingSafeEqual(rows[0].writeKey, writeKey);
       },
 
       writeMessages: (ownerId, messages) => {