@instantdb/react 0.22.75 → 0.22.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instantdb/react",
-  "version": "0.22.75",
+  "version": "0.22.76",
   "description": "Instant DB for React",
   "homepage": "https://github.com/instantdb/instant/tree/main/client/packages/react",
   "repository": {
@@ -54,12 +54,14 @@
   },
   "dependencies": {
     "eventsource": "^4.0.0",
-    "@instantdb/core": "0.22.75",
-    "@instantdb/react-common": "0.22.75",
-    "@instantdb/version": "0.22.75"
+    "@instantdb/react-common": "0.22.76",
+    "@instantdb/version": "0.22.76",
+    "@instantdb/core": "0.22.76"
   },
   "scripts": {
     "test": "vitest",
+    "test:types": "tsc -p tsconfig.test.json --noEmit",
+    "test:ci": "pnpm run test:types",
     "check-exports": "attw --pack .",
     "dev": "tsc --watch --preserveWatchOutput -p tsconfig.dev.json",
     "clean": "rm -rf dist",

package/src/Cursors.tsx

@@ -41,7 +41,7 @@ export function Cursors<
     _spaceId || `cursors-space-default--${String(room.type)}-${room.id}`;
 
   const cursorsPresence = room.usePresence({
-    keys: [spaceId],
+    keys: [spaceId] as (keyof RoomSchema[RoomType]['presence'])[],
   });
 
   const fullPresence = room._core._reactor.getPresence(room.type, room.id);
@@ -142,7 +142,7 @@ export function Cursors<
               {renderCursor ? (
                 renderCursor({
                   color: cursor.color,
-                  presence: fullPresence.peers[id],
+                  presence: fullPresence?.peers[id],
                 })
               ) : (
                 <Cursor {...cursor} />

package/src/InstantReactWebDatabase.ts

@@ -4,10 +4,11 @@ import { EventSource } from 'eventsource';
 
 export default class InstantReactWebDatabase<
   Schema extends InstantSchemaDef<any, any, any>,
-  Config extends InstantConfig<Schema, boolean> = InstantConfig<
+  UseDates extends boolean = false,
+  Config extends InstantConfig<Schema, UseDates> = InstantConfig<
     Schema,
-    boolean
+    UseDates
   >,
-> extends InstantReactAbstractDatabase<Schema, Config> {
+> extends InstantReactAbstractDatabase<Schema, UseDates, Config> {
   static EventSourceImpl = EventSource;
 }

package/src/__types__/typeUtils.ts

@@ -0,0 +1,39 @@
+// Type testing utils from
+// https://github.com/type-challenges/type-challenges/blob/main/utils/index.d.ts
+
+export type Expect<T extends true> = T;
+export type ExpectTrue<T extends true> = T;
+export type ExpectFalse<T extends false> = T;
+export type IsTrue<T extends true> = T;
+export type IsFalse<T extends false> = T;
+
+export type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+
+// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type NotAny<T> = true extends IsAny<T> ? false : true;
+
+export type Debug<T> = { [K in keyof T]: T[K] };
+export type MergeInsertions<T> = T extends object
+  ? { [K in keyof T]: MergeInsertions<T[K]> }
+  : T;
+
+export type Alike<X, Y> = Equal<MergeInsertions<X>, MergeInsertions<Y>>;
+
+export type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE
+  ? true
+  : false;
+export type ExpectValidArgs<
+  FUNC extends (...args: any[]) => any,
+  ARGS extends any[],
+> = ARGS extends Parameters<FUNC> ? true : false;
+
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;

package/src/__types__/typesTests.ts

@@ -0,0 +1,86 @@
+import type { Equal, Expect, IsAny, NotAny } from './typeUtils.ts';
+import { i, init } from '../index.ts';
+
+const schema = i.schema({
+  entities: {
+    tbl: i.entity({
+      d: i.date().indexed(),
+      dOptional: i.date().optional(),
+    }),
+  },
+});
+
+function _testUseDatesTest() {
+  const db = init({
+    schema,
+    appId: '123',
+    useDateObjects: true,
+  });
+
+  const { data } = db.useQuery({ tbl: {} });
+  const item = data?.tbl[0];
+  if (item) {
+    type t = typeof item.d;
+    type _cases = [Expect<NotAny<t>>, Expect<Equal<t, Date>>];
+
+    type tOpt = typeof item.dOptional;
+    type _cases_2 = [
+      Expect<NotAny<tOpt>>,
+      Expect<Equal<tOpt, Date | undefined>>,
+    ];
+  }
+}
+
+function _testUseDatesFalseTest() {
+  const db = init({
+    schema,
+    appId: '123',
+    useDateObjects: false,
+  });
+
+  const { data } = db.useQuery({ tbl: {} });
+  const item = data?.tbl[0];
+  if (item) {
+    type t = typeof item.d;
+    type _cases = [Expect<NotAny<t>>, Expect<Equal<t, string | number>>];
+
+    type tOpt = typeof item.dOptional;
+    type _cases_2 = [
+      Expect<NotAny<tOpt>>,
+      Expect<Equal<tOpt, string | number | undefined>>,
+    ];
+  }
+}
+
+function _testUseDatesUndefinedTest() {
+  const db = init({
+    schema,
+    appId: '123',
+  });
+
+  const { data } = db.useQuery({ tbl: {} });
+  const item = data?.tbl[0];
+  if (item) {
+    type t = typeof item.d;
+    type _cases = [Expect<NotAny<t>>, Expect<Equal<t, string | number>>];
+
+    type tOpt = typeof item.dOptional;
+    type _cases_2 = [
+      Expect<NotAny<tOpt>>,
+      Expect<Equal<tOpt, string | number | undefined>>,
+    ];
+  }
+}
+
+function _testDataNoSchema() {
+  const db = init({
+    appId: '123',
+  });
+
+  const { data } = db.useQuery({ tbl: {} });
+  const item = data?.tbl[0];
+  if (item) {
+    type t = typeof item.d;
+    type _cases = [Expect<IsAny<t>>, Expect<Equal<typeof item.id, string>>];
+  }
+}

package/src/init.ts

@@ -31,14 +31,23 @@ export function init<
   Schema extends InstantSchemaDef<any, any, any> = InstantUnknownSchema,
   UseDates extends boolean = false,
 >(
-  config: InstantConfig<Schema, UseDates>,
-): InstantReactWebDatabase<Schema, InstantConfig<Schema, UseDates>> {
-  return new InstantReactWebDatabase<Schema, InstantConfig<Schema, UseDates>>(
-    config,
-    {
-      '@instantdb/react': version,
-    },
-  );
+  // Allows config with missing `useDateObjects`, but keeps `UseDates`
+  // as a non-nullable in the InstantConfig type.
+  config: Omit<InstantConfig<Schema, UseDates>, 'useDateObjects'> & {
+    useDateObjects?: UseDates;
+  },
+): InstantReactWebDatabase<Schema, UseDates, InstantConfig<Schema, UseDates>> {
+  const configStrict = {
+    ...config,
+    useDateObjects: (config.useDateObjects ?? false) as UseDates,
+  };
+  return new InstantReactWebDatabase<
+    Schema,
+    UseDates,
+    InstantConfig<Schema, UseDates>
+  >(configStrict, {
+    '@instantdb/react': version,
+  });
 }
 
 /**

package/tsconfig.json

@@ -1,11 +1,12 @@
 {
   "extends": "../../tsconfig.base.json",
   "include": ["src"],
-  "exclude": ["node_modules", "dist"],
+  "exclude": ["node_modules", "dist", "src/__types__"],
   "compilerOptions": {
     "outDir": "dist/tsc",
     "rewriteRelativeImportExtensions": true,
     "rootDir": "src",
-    "jsx": "react-jsx"
+    "jsx": "react-jsx",
+    "strictNullChecks": true
   }
 }

package/tsconfig.test.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src", "src/__types__"],
+  "exclude": ["node_modules", "dist"]
+}