feat: typesafe nested object and array types

Author: Rettend

packages/idb-orm/src/builders/base.ts

@@ -1,5 +1,5 @@
 import type { DatabaseSchema, Operation } from '../types'
-import { selectFields, uuid } from '../utils'
+import { isPrimaryKeyField, selectFields, uuid } from '../utils'
 
 export abstract class BaseQueryBuilder<
   TSchema extends DatabaseSchema,
@@ -105,7 +105,7 @@ export abstract class BaseQueryBuilder<
 
   private ensurePrimaryKey(data: any): void {
     const pkField = Object.entries(this.tableSchema).find(
-      ([_, field]) => field.primaryKey,
+      ([_, field]) => isPrimaryKeyField(field) && field.primaryKey,
     )
 
     if (pkField) {

packages/idb-orm/src/orm.ts

@@ -1,5 +1,6 @@
-import type { DatabaseResults, DatabaseSchema } from './types'
+import type { DatabaseResults, DatabaseSchema, PrimitiveFieldSchema } from './types'
 import { QueryBuilder } from './builders/query'
+import { isPrimaryKeyField } from './utils'
 
 export class IdbOrm<TSchema extends DatabaseSchema> {
   public dbName: string
@@ -35,7 +36,7 @@ export class IdbOrm<TSchema extends DatabaseSchema> {
         Object.entries(this.schema).forEach(([tableName, tableSchema]) => {
           if (!db.objectStoreNames.contains(tableName)) {
             const pkField = Object.entries(tableSchema).find(
-              ([_, field]) => field.primaryKey,
+              ([_, field]) => isPrimaryKeyField(field) && field.primaryKey,
             )
 
             if (!pkField)
@@ -44,7 +45,7 @@ export class IdbOrm<TSchema extends DatabaseSchema> {
             const [keyPath, field] = pkField
             db.createObjectStore(tableName, {
               keyPath,
-              autoIncrement: field.autoIncrement ?? false,
+              autoIncrement: (field as PrimitiveFieldSchema<any>).autoIncrement ?? false,
             })
           }
         })

packages/idb-orm/src/types.ts

@@ -1,27 +1,66 @@
-export type Field = 'string' | 'number' | 'boolean' | 'object' | 'array'
+export type PrimitiveField = 'string' | 'number' | 'boolean'
+
+// Schema field definitions for nested structures
+export interface ArrayFieldSchema<T = any> {
+  type: 'array'
+  items: SchemaField
+  required?: boolean
+  default?: T[] | (() => T[])
+}
+
+export interface ObjectFieldSchema<T = any> {
+  type: 'object'
+  props: { [K in keyof T]: SchemaField }
+  required?: boolean
+  default?: T | (() => T)
+}
+
+export interface PrimitiveFieldSchema<T extends PrimitiveField> {
+  type: T
+  required?: boolean
+  default?: TypeMap[T] | (() => TypeMap[T])
+  primaryKey?: boolean
+  autoIncrement?: boolean
+}
+
+export type SchemaField =
+  | PrimitiveFieldSchema<PrimitiveField>
+  | ArrayFieldSchema
+  | ObjectFieldSchema
 
 export interface TypeMap {
   string: string
   number: number
   boolean: boolean
-  object: object
-  array: any[]
 }
 
-export type SchemaField = {
-  [T in Field]: {
-    type: T
-    required?: boolean
-    default?: TypeMap[T] | (() => TypeMap[T])
-    primaryKey?: boolean
-    autoIncrement?: boolean
-  }
-}[Field]
+// Helper type to infer the actual TypeScript type from a schema field
+export type InferField<T extends SchemaField> = T extends PrimitiveFieldSchema<infer P>
+  ? TypeMap[P]
+  : T extends ArrayFieldSchema
+    ? InferField<T['items']>[]
+    : T extends ObjectFieldSchema
+      ? { [K in keyof T['props']]: InferField<T['props'][K]> }
+      : never
 
 export interface TableSchema {
   [key: string]: SchemaField
 }
 
+export type InferSchemaType<T extends TableSchema> = {
+  [K in keyof T as T[K] extends { primaryKey: true }
+    ? K
+    : T[K] extends { required: true } | { default: any }
+      ? K
+      : never]: InferField<T[K]>
+} & {
+  [K in keyof T as T[K] extends { primaryKey: true }
+    ? never
+    : T[K] extends { required: true } | { default: any }
+      ? never
+      : K]?: InferField<T[K]>
+}
+
 export type PrimaryKeyField<T extends TableSchema> = {
   [K in keyof T]: T[K] extends { primaryKey: true } ? K : never
 }[keyof T]
@@ -47,30 +86,18 @@ export interface FilterCondition {
   value: any
 }
 
-export type InferValue<T extends SchemaField> = TypeMap[T['type']]
+export type InferValue<T extends SchemaField> = T extends PrimitiveFieldSchema<infer P>
+  ? TypeMap[P]
+  : T extends ArrayFieldSchema
+    ? InferField<T['items']>[]
+    : T extends ObjectFieldSchema
+      ? { [K in keyof T['props']]: InferField<T['props'][K]> }
+      : never
 
 export type FieldType<T extends TableSchema, K extends keyof T> = InferValue<T[K]>
 
-export type InferSchemaType<T extends TableSchema> = {
-  [K in keyof T as T[K] extends { primaryKey: true }
-    ? K
-    : T[K] extends { required: true } | { default: any }
-      ? K
-      : never]: InferValue<T[K]>
-} & {
-  [K in keyof T as T[K] extends { primaryKey: true }
-    ? never
-    : T[K] extends { required: true } | { default: any }
-      ? never
-      : K]?: InferValue<T[K]>
-}
-
 type HasDefault<T extends SchemaField> = T extends { default: any } ? true : false
 
-// type DefaultKeys<T extends TableSchema> = {
-//   [K in keyof T]: HasDefault<T[K]> extends true ? K : never
-// }[keyof T]
-
 type RequiredKeys<T extends TableSchema> = {
   [K in keyof T]: T[K] extends { required: true }
     ? HasDefault<T[K]> extends true ? never : K

packages/idb-orm/src/utils.ts

@@ -1,3 +1,9 @@
+import type { PrimitiveFieldSchema } from './types'
+
+export function isPrimaryKeyField(field: any): field is PrimitiveFieldSchema<any> {
+  return 'primaryKey' in field
+}
+
 export function selectFields<T extends object, K extends keyof T>(
   obj: T,
   fields: K[],

packages/idb-orm/test/advanced.test.ts

@@ -8,8 +8,20 @@ const advancedSchema = {
     price: { type: 'number', required: true },
     category: { type: 'string', required: true },
     inStock: { type: 'boolean', default: false },
-    tags: { type: 'array', default: [] },
-    metadata: { type: 'object', default: {} },
+    tags: {
+      type: 'array',
+      items: { type: 'string' },
+      default: [],
+    },
+    metadata: {
+      type: 'object',
+      props: {
+        edition: { type: 'string' },
+        serialNumber: { type: 'string' },
+        test: { type: 'boolean', required: false },
+      },
+      default: {},
+    },
   },
   orders: {
     id: { type: 'number', primaryKey: true, autoIncrement: true },

packages/idb-orm/test/nested.test.ts

@@ -7,25 +7,55 @@ const nestedSchema = {
     name: { type: 'string', required: true },
     metadata: {
       type: 'object',
+      props: {
+        createdBy: { type: 'string' },
+        version: { type: 'number' },
+        updated: { type: 'boolean' },
+        config: {
+          type: 'object',
+          props: {
+            setting1: { type: 'boolean' },
+            setting2: { type: 'boolean' },
+          },
+        },
+        nested: {
+          type: 'object',
+          props: {
+            deep: {
+              type: 'object',
+              props: {
+                value: { type: 'boolean' },
+              },
+            },
+          },
+        },
+      },
       default: {},
     },
     tags: {
       type: 'array',
+      items: { type: 'string' },
       default: [],
     },
     attributes: {
       type: 'object',
-      default: {
-        color: 'default',
-        size: 'medium',
+      props: {
+        color: { type: 'string' },
+        size: { type: 'string' },
+        material: { type: 'string' },
       },
+      default: { color: 'default', size: 'medium' },
     },
     variants: {
       type: 'array',
-      default: () => [{
-        name: 'default',
-        stock: 0,
-      }],
+      items: {
+        type: 'object',
+        props: {
+          name: { type: 'string' },
+          stock: { type: 'number' },
+        },
+      },
+      default: () => [{ name: 'default', stock: 0 }],
     },
   },
 } satisfies DatabaseSchema

packages/idb-orm/test/type.test.ts

@@ -8,7 +8,10 @@ const schema = {
     name: { type: 'string', required: true },
     email: { type: 'string' },
     age: { type: 'number', required: true },
-    meta: { type: 'object' },
+    meta: {
+      type: 'object',
+      
+    },
   },
   posts: {
     id: { type: 'number', primaryKey: true, autoIncrement: true },