[union] Type-check schema defaults

Author: jamesgpearce

src/@types/_internal/store/with-schemas/index.d.ts

@@ -5,7 +5,9 @@ import type {
   OptionalTablesSchema,
   OptionalValuesSchema,
   Store,
+  TablesSchema,
   Value,
+  ValuesSchema,
 } from '../../../store/with-schemas/index.d.ts';
 
 export type TableIdFromSchema<Schema extends OptionalTablesSchema> = AsId<
@@ -94,10 +96,10 @@ export type CellIsDefaultedFromSchema<
   CellId extends CellIdFromSchema<Schema, TableId>,
   Then,
   Else,
-> = Schema[TableId][CellId] extends {
-  default: infer _;
-}
-  ? Then
+> = Schema[TableId][CellId] extends {default: infer Default}
+  ? [Default] extends [Cell<Schema, TableId, CellId>]
+    ? Then
+    : Else
   : Else;
 
 export type CellIsRequiredFromSchema<
@@ -190,12 +192,45 @@ export type ValueIsDefaultedFromSchema<
   ValueId extends ValueIdFromSchema<Schema>,
   Then,
   Else,
-> = Schema[ValueId] extends {
-  default: infer _;
-}
-  ? Then
+> = Schema[ValueId] extends {default: infer Default}
+  ? [Default] extends [Value<Schema, ValueId>]
+    ? Then
+    : Else
   : Else;
 
+type ValidCellDefault<
+  Schema extends TablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId>,
+> = Schema[TableId][CellId] extends {default: infer Default}
+  ? [Default] extends [Cell<Schema, TableId, CellId>]
+    ? unknown
+    : never
+  : unknown;
+
+export type ValidTablesSchema<Schema extends TablesSchema> = {
+  [TableId in TableIdFromSchema<Schema>]: {
+    [CellId in CellIdFromSchema<Schema, TableId>]: ValidCellDefault<
+      Schema,
+      TableId,
+      CellId
+    >;
+  };
+};
+
+type ValidValueDefault<
+  Schema extends ValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema>,
+> = Schema[ValueId] extends {default: infer Default}
+  ? [Default] extends [Value<Schema, ValueId>]
+    ? unknown
+    : never
+  : unknown;
+
+export type ValidValuesSchema<Schema extends ValuesSchema> = {
+  [ValueId in ValueIdFromSchema<Schema>]: ValidValueDefault<Schema, ValueId>;
+};
+
 export type ValueIsRequiredFromSchema<
   Schema extends OptionalValuesSchema,
   ValueId extends ValueIdFromSchema<Schema>,

src/@types/mergeable-store/with-schemas/index.d.ts

@@ -2,6 +2,8 @@
 import type {
   CellIdFromSchema,
   TableIdFromSchema,
+  ValidTablesSchema,
+  ValidValuesSchema,
   ValueIdFromSchema,
 } from '../../_internal/store/with-schemas/index.d.ts';
 import type {GetNow, Hash, Hlc, Id} from '../../common/with-schemas/index.d.ts';
@@ -239,25 +241,25 @@ export interface MergeableStore<
   isMergeable(): boolean;
 
   /// Store.setTablesSchema
-  setTablesSchema<TS extends TablesSchema>(
-    tablesSchema: TS,
-  ): MergeableStore<[typeof tablesSchema, Schemas[1]]>;
+  setTablesSchema<const TS extends TablesSchema>(
+    tablesSchema: TS & ValidTablesSchema<TS>,
+  ): MergeableStore<[TS, Schemas[1]]>;
 
   /// Store.setValuesSchema
-  setValuesSchema<VS extends ValuesSchema>(
-    valuesSchema: VS,
-  ): MergeableStore<[Schemas[0], typeof valuesSchema]>;
+  setValuesSchema<const VS extends ValuesSchema>(
+    valuesSchema: VS & ValidValuesSchema<VS>,
+  ): MergeableStore<[Schemas[0], VS]>;
 
   /// Store.setSchema
-  setSchema<TS extends TablesSchema, VS extends ValuesSchema>(
-    tablesSchema: TS,
-    valuesSchema?: VS,
+  setSchema<const TS extends TablesSchema, const VS extends ValuesSchema>(
+    tablesSchema: TS & ValidTablesSchema<TS>,
+    valuesSchema?: VS & ValidValuesSchema<VS>,
   ): MergeableStore<
     [
-      typeof tablesSchema,
+      TS,
       Exclude<ValuesSchema, typeof valuesSchema> extends never
         ? NoValuesSchema
-        : NonNullable<typeof valuesSchema>,
+        : VS,
     ]
   >;
 

src/@types/store/docs.js

@@ -57,10 +57,11 @@
  * Set `allowNull` to `true` to also allow `null`, whether the schema uses
  * `type` or `enum`. A default value is used only when it has the correct type,
  * matches any member of a type union, is an enum member when applicable, or is
- * `null` when allowed. A valid default means that the Cell will always be
- * present in a Row. You can also set `required` to `true` to indicate to
- * schema-based typing that the Cell should be present even if it does not have
- * a default.
+ * `null` when allowed. Literal schemas passed to Store schema setters are
+ * checked against these default rules by TypeScript. A valid default means
+ * that the Cell will always be present in a Row. You can also set `required`
+ * to `true` to indicate to schema-based typing that the Cell should be present
+ * even if it does not have a default.
  *
  * If neither a default value nor `required: true` is provided, the Cell may be
  * missing from the Row, but when present you can be guaranteed it is of the
@@ -170,10 +171,11 @@
  * Set `allowNull` to `true` to also allow `null`, whether the schema uses
  * `type` or `enum`. A default value is used only when it has the correct type,
  * matches any member of a type union, is an enum member when applicable, or is
- * `null` when allowed. A valid default means that the Value will always be
- * present in a Store. You can also set `required` to `true` to indicate to
- * schema-based typing that the Value should be present even if it does not have
- * a default.
+ * `null` when allowed. Literal schemas passed to Store schema setters are
+ * checked against these default rules by TypeScript. A valid default means
+ * that the Value will always be present in a Store. You can also set `required`
+ * to `true` to indicate to schema-based typing that the Value should be present
+ * even if it does not have a default.
  *
  * If neither a default value nor `required: true` is provided, the Value may
  * not be present in the Store, but when present you can be guaranteed it is of

src/@types/store/index.d.ts

@@ -14,6 +14,46 @@ type SchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array';
 
 type SchemaTypeArray = readonly [SchemaType, ...SchemaType[]];
 
+type CellOrValueFromSchemaType<Type> = Type extends readonly (infer Type)[]
+  ? CellOrValueFromSchemaType<Type>
+  : Type extends 'string'
+    ? string
+    : Type extends 'number'
+      ? number
+      : Type extends 'boolean'
+        ? boolean
+        : Type extends 'object'
+          ? AnyObject
+          : Type extends 'array'
+            ? AnyArray
+            : never;
+
+type CellOrValueFromSchema<Schema> = Schema extends {
+  enum: readonly (infer Enum)[];
+}
+  ? Enum
+  : Schema extends {type: infer Type}
+    ? CellOrValueFromSchemaType<Type>
+    : never;
+
+type NullFromSchema<Schema> = Schema extends {allowNull: true} ? null : never;
+
+type ValidDefault<Schema> = Schema extends {default: infer Default}
+  ? [Default] extends [CellOrValueFromSchema<Schema> | NullFromSchema<Schema>]
+    ? unknown
+    : never
+  : unknown;
+
+type ValidTablesSchema<Schema extends TablesSchema> = {
+  [TableId in keyof Schema]: {
+    [CellId in keyof Schema[TableId]]: ValidDefault<Schema[TableId][CellId]>;
+  };
+};
+
+type ValidValuesSchema<Schema extends ValuesSchema> = {
+  [ValueId in keyof Schema]: ValidDefault<Schema[ValueId]>;
+};
+
 /// TablesSchema
 export type TablesSchema = {[tableId: Id]: {[cellId: Id]: CellSchema}};
 
@@ -679,13 +719,20 @@ export interface Store {
   setJson(tablesAndValuesJson: Json): this;
 
   /// Store.setTablesSchema
-  setTablesSchema(tablesSchema: TablesSchema): this;
+  setTablesSchema<const TS extends TablesSchema>(
+    tablesSchema: TS & ValidTablesSchema<TS>,
+  ): this;
 
   /// Store.setValuesSchema
-  setValuesSchema(valuesSchema: ValuesSchema): this;
+  setValuesSchema<const VS extends ValuesSchema>(
+    valuesSchema: VS & ValidValuesSchema<VS>,
+  ): this;
 
   /// Store.setSchema
-  setSchema(tablesSchema: TablesSchema, valuesSchema?: ValuesSchema): this;
+  setSchema<const TS extends TablesSchema, const VS extends ValuesSchema>(
+    tablesSchema: TS & ValidTablesSchema<TS>,
+    valuesSchema?: VS & ValidValuesSchema<VS>,
+  ): this;
 
   /// Store.delTables
   delTables(): this;

src/@types/store/with-schemas/index.d.ts

@@ -11,6 +11,8 @@ import type {
   StoreAlias,
   TableIdFromSchema,
   Truncate,
+  ValidTablesSchema,
+  ValidValuesSchema,
   ValueIdFromSchema,
 } from '../../_internal/store/with-schemas/index.d.ts';
 import type {
@@ -1258,25 +1260,25 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   setJson(tablesAndValuesJson: Json): this;
 
   /// Store.setTablesSchema
-  setTablesSchema<TS extends TablesSchema>(
-    tablesSchema: TS,
-  ): Store<[typeof tablesSchema, Schemas[1]]>;
+  setTablesSchema<const TS extends TablesSchema>(
+    tablesSchema: TS & ValidTablesSchema<TS>,
+  ): Store<[TS, Schemas[1]]>;
 
   /// Store.setValuesSchema
-  setValuesSchema<VS extends ValuesSchema>(
-    valuesSchema: VS,
-  ): Store<[Schemas[0], typeof valuesSchema]>;
+  setValuesSchema<const VS extends ValuesSchema>(
+    valuesSchema: VS & ValidValuesSchema<VS>,
+  ): Store<[Schemas[0], VS]>;
 
   /// Store.setSchema
-  setSchema<TS extends TablesSchema, VS extends ValuesSchema>(
-    tablesSchema: TS,
-    valuesSchema?: VS,
+  setSchema<const TS extends TablesSchema, const VS extends ValuesSchema>(
+    tablesSchema: TS & ValidTablesSchema<TS>,
+    valuesSchema?: VS & ValidValuesSchema<VS>,
   ): Store<
     [
-      typeof tablesSchema,
+      TS,
       Exclude<ValuesSchema, typeof valuesSchema> extends never
         ? NoValuesSchema
-        : NonNullable<typeof valuesSchema>,
+        : VS,
     ]
   >;