pomegranate-db 1.0.0 → 1.1.0

package/README.md

@@ -12,6 +12,10 @@
   Build powerful React and React Native apps that scale from hundreds to tens of thousands of records and remain <em>fast</em> ⚡️
 </p>
 
+<p align="center">
+  <a href="https://snack.expo.dev/@bobbyquantum/pomegranate-snack">Try the live Expo Snack demo</a>
+</p>
+
 ---
 
 ### ⚡️ Instant Launch

package/dist/database/Database.d.ts

@@ -96,6 +96,14 @@ export declare class Database implements ModelDatabaseRef {
     batch(operations: BatchOperation[]): Promise<void>;
     /** @internal used by Model */
     _batch(operations: BatchOperation[]): Promise<void>;
+    /** @internal Find a record by table+id for relation resolution */
+    _findById(table: string, id: string): Promise<Model | null>;
+    /** @internal Observe a record by table+id for relation resolution */
+    _observeById(table: string, id: string): Observable<Model | null>;
+    /** @internal Fetch related records for has-many relation */
+    _fetchRelated(table: string, foreignKey: string, id: string): Promise<Model[]>;
+    /** @internal Observe related records for has-many relation */
+    _observeRelated(table: string, foreignKey: string, id: string): Observable<Model[]>;
     /**
      * Run a sync cycle.
      * See sync/index.ts for the full implementation.

package/dist/database/Database.js

@@ -221,6 +221,45 @@ class Database {
     async _batch(operations) {
         await this._adapter.batch(operations);
     }
+    // ─── Relation Resolution (RelationDatabaseRef) ─────────────────────
+    /** @internal Find a record by table+id for relation resolution */
+    async _findById(table, id) {
+        const collection = this._collections.get(table);
+        if (!collection) {
+            throw new Error(`No collection registered for table "${table}"`);
+        }
+        return collection.findById(id);
+    }
+    /** @internal Observe a record by table+id for relation resolution */
+    _observeById(table, id) {
+        const collection = this._collections.get(table);
+        if (!collection) {
+            throw new Error(`No collection registered for table "${table}"`);
+        }
+        return collection.observeById(id);
+    }
+    /** @internal Fetch related records for has-many relation */
+    async _fetchRelated(table, foreignKey, id) {
+        const collection = this._collections.get(table);
+        if (!collection) {
+            throw new Error(`No collection registered for table "${table}"`);
+        }
+        const qb = collection.query((q) => {
+            q.where(foreignKey, 'eq', id);
+        });
+        return collection.fetch(qb);
+    }
+    /** @internal Observe related records for has-many relation */
+    _observeRelated(table, foreignKey, id) {
+        const collection = this._collections.get(table);
+        if (!collection) {
+            throw new Error(`No collection registered for table "${table}"`);
+        }
+        const qb = collection.query((q) => {
+            q.where(foreignKey, 'eq', id);
+        });
+        return collection.observeQuery(qb);
+    }
     // ─── Sync ──────────────────────────────────────────────────────────
     /**
      * Run a sync cycle.

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * Reactive offline-first database with sync support.
  */
 export { m } from './schema';
-export type { ColumnType, ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, RelationDescriptor, FieldDescriptor, SchemaFields, ModelSchema, ResolvedColumn, ResolvedRelation, DatabaseSchema, TableSchema, SyncStatus, RawRecord, InferCreatePatch, InferUpdatePatch, InferRecord, } from './schema';
+export type { ColumnType, ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, RelationDescriptor, FieldDescriptor, SchemaFields, ModelSchema, ResolvedColumn, ResolvedRelation, DatabaseSchema, TableSchema, SyncStatus, RawRecord, InferCreatePatch, InferUpdatePatch, InferRecord, BelongsToRelation, HasManyRelation, ModelInstance, } from './schema';
 export { Model } from './model';
 export type { ModelStatic } from './model';
 export { Collection } from './collection';

package/dist/model/Model.d.ts

@@ -14,8 +14,9 @@
  *     });
  *   }
  */
-import type { ModelSchema, RawRecord, SyncStatus } from '../schema/types';
+import type { ModelSchema, RawRecord, SyncStatus, BelongsToDescriptor, HasManyDescriptor, BelongsToRelation, HasManyRelation } from '../schema/types';
 import type { Observable } from '../observable/Subject';
+import type { RelationDatabaseRef } from './Relation';
 /** Minimal interface for what a Collection provides to a Model */
 export interface ModelCollectionRef {
     readonly table: string;
@@ -25,7 +26,7 @@ export interface ModelCollectionRef {
     _getDatabase(): ModelDatabaseRef;
 }
 /** Minimal interface for what a Database provides */
-export interface ModelDatabaseRef {
+export interface ModelDatabaseRef extends RelationDatabaseRef {
     _ensureInWriter(action: string): void;
     _batch(operations: Array<{
         type: string;
@@ -56,6 +57,28 @@ export declare class Model<S extends ModelSchema = ModelSchema> {
      * Get a field value, converting from raw storage form.
      */
     getField(fieldName: string): unknown;
+    /**
+     * Get a typed belongs-to relation handle.
+     *
+     * The return type is inferred from the schema: if the field is a
+     * BelongsToDescriptor<UserSchema>, the return is BelongsToRelation<UserSchema>.
+     *
+     * Usage in subclass:
+     *   get author() { return this.belongsTo('author'); }
+     *   // TS infers: BelongsToRelation<typeof UserSchema>
+     */
+    belongsTo<K extends keyof S['fields'] & string>(fieldName: K): S['fields'][K] extends BelongsToDescriptor<infer RS> ? BelongsToRelation<RS> : BelongsToRelation;
+    /**
+     * Get a typed has-many relation handle.
+     *
+     * The return type is inferred from the schema: if the field is a
+     * HasManyDescriptor<CommentSchema>, the return is HasManyRelation<CommentSchema>.
+     *
+     * Usage in subclass:
+     *   get comments() { return this.hasMany('comments'); }
+     *   // TS infers: HasManyRelation<typeof CommentSchema>
+     */
+    hasMany<K extends keyof S['fields'] & string>(fieldName: K): S['fields'][K] extends HasManyDescriptor<infer RS> ? HasManyRelation<RS> : HasManyRelation;
     /**
      * Set field value(s) on the raw record (does NOT persist — internal use).
      */

package/dist/model/Model.js

@@ -20,6 +20,7 @@ exports.Model = void 0;
 exports.createRawRecord = createRawRecord;
 const Subject_1 = require("../observable/Subject");
 const utils_1 = require("../utils");
+const Relation_1 = require("./Relation");
 class Model {
     static schema;
     /** The record id */
@@ -66,15 +67,54 @@ class Model {
         const col = schema.columns.find((c) => c.fieldName === fieldName);
         if (!col) {
             // Check if it's a relation field name
-            const rel = schema.relations.find((r) => r.fieldName === fieldName);
-            if (rel && rel.kind === 'belongs_to') {
-                return this.#raw[rel.foreignKey];
+            const relation = schema.relations.find((r) => r.fieldName === fieldName);
+            if (relation && relation.kind === 'belongs_to') {
+                return this.#raw[relation.foreignKey];
             }
             throw new Error(`Unknown field "${fieldName}" on table "${schema.table}"`);
         }
         const rawValue = this.#raw[col.columnName];
         return deserializeValue(col, rawValue);
     }
+    // ─── Relation Accessors ─────────────────────────────────────────────
+    /**
+     * Get a typed belongs-to relation handle.
+     *
+     * The return type is inferred from the schema: if the field is a
+     * BelongsToDescriptor<UserSchema>, the return is BelongsToRelation<UserSchema>.
+     *
+     * Usage in subclass:
+     *   get author() { return this.belongsTo('author'); }
+     *   // TS infers: BelongsToRelation<typeof UserSchema>
+     */
+    belongsTo(fieldName) {
+        const schema = this.constructor.schema;
+        const relation = schema.relations.find((r) => r.fieldName === fieldName && r.kind === 'belongs_to');
+        if (!relation) {
+            throw new Error(`No belongs_to relation "${fieldName}" on table "${schema.table}"`);
+        }
+        const db = this.collection._getDatabase();
+        return new Relation_1.BelongsToRelationImpl(() => this.#raw[relation.foreignKey] ?? null, relation._relatedSchemaThunk, db);
+    }
+    /**
+     * Get a typed has-many relation handle.
+     *
+     * The return type is inferred from the schema: if the field is a
+     * HasManyDescriptor<CommentSchema>, the return is HasManyRelation<CommentSchema>.
+     *
+     * Usage in subclass:
+     *   get comments() { return this.hasMany('comments'); }
+     *   // TS infers: HasManyRelation<typeof CommentSchema>
+     */
+    hasMany(fieldName) {
+        const schema = this.constructor.schema;
+        const relation = schema.relations.find((r) => r.fieldName === fieldName && r.kind === 'has_many');
+        if (!relation) {
+            throw new Error(`No has_many relation "${fieldName}" on table "${schema.table}"`);
+        }
+        const db = this.collection._getDatabase();
+        return new Relation_1.HasManyRelationImpl(this.id, relation.foreignKey, relation._relatedSchemaThunk, db);
+    }
     /**
      * Set field value(s) on the raw record (does NOT persist — internal use).
      */
@@ -125,10 +165,10 @@ class Model {
             }
             else {
                 // Check belongs_to
-                const rel = schema.relations.find((r) => r.fieldName === fieldName && r.kind === 'belongs_to');
-                if (rel) {
-                    rawUpdates[rel.foreignKey] = value;
-                    changedColumns.push(rel.foreignKey);
+                const relation = schema.relations.find((r) => r.fieldName === fieldName && r.kind === 'belongs_to');
+                if (relation) {
+                    rawUpdates[relation.foreignKey] = value;
+                    changedColumns.push(relation.foreignKey);
                 }
                 else {
                     throw new Error(`Unknown field "${fieldName}" on table "${schema.table}"`);

package/dist/model/Relation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Relation wrappers — lazy handles for fetching/observing related records.
+ *
+ * These are thin facades over Collection primitives. They are created on-demand
+ * by Model.belongsTo() and Model.hasMany() and carry the related schema type
+ * so TypeScript can infer the related model.
+ */
+import type { ModelSchema, BelongsToRelation, HasManyRelation, ModelInstance } from '../schema/types';
+import type { Observable } from '../observable/Subject';
+/**
+ * Minimal interface a relation needs to reach the database.
+ * Avoids importing Database directly (circular dep).
+ */
+export interface RelationDatabaseRef {
+    _findById(table: string, id: string): Promise<ModelInstance | null>;
+    _observeById(table: string, id: string): Observable<ModelInstance | null>;
+    _fetchRelated(table: string, foreignKey: string, id: string): Promise<ModelInstance[]>;
+    _observeRelated(table: string, foreignKey: string, id: string): Observable<ModelInstance[]>;
+}
+export declare class BelongsToRelationImpl<S extends ModelSchema = ModelSchema> implements BelongsToRelation<S> {
+    private _getFkValue;
+    private _relatedSchemaThunk;
+    private _db;
+    constructor(getFkValue: () => string | null, relatedSchemaThunk: () => S, db: RelationDatabaseRef);
+    get id(): string | null;
+    fetch(): Promise<ModelInstance<S> | null>;
+    observe(): Observable<ModelInstance<S> | null>;
+}
+export declare class HasManyRelationImpl<S extends ModelSchema = ModelSchema> implements HasManyRelation<S> {
+    private _ownerId;
+    private _foreignKey;
+    private _relatedSchemaThunk;
+    private _db;
+    constructor(ownerId: string, foreignKey: string, relatedSchemaThunk: () => S, db: RelationDatabaseRef);
+    fetch(): Promise<ModelInstance<S>[]>;
+    observe(): Observable<ModelInstance<S>[]>;
+}

package/dist/model/Relation.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Relation wrappers — lazy handles for fetching/observing related records.
+ *
+ * These are thin facades over Collection primitives. They are created on-demand
+ * by Model.belongsTo() and Model.hasMany() and carry the related schema type
+ * so TypeScript can infer the related model.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyRelationImpl = exports.BelongsToRelationImpl = void 0;
+const noop = () => { };
+// ─── BelongsToRelationImpl ──────────────────────────────────────────────────
+class BelongsToRelationImpl {
+    _getFkValue;
+    _relatedSchemaThunk;
+    _db;
+    constructor(getFkValue, relatedSchemaThunk, db) {
+        this._getFkValue = getFkValue;
+        this._relatedSchemaThunk = relatedSchemaThunk;
+        this._db = db;
+    }
+    get id() {
+        return this._getFkValue();
+    }
+    async fetch() {
+        const fk = this._getFkValue();
+        if (!fk)
+            return null;
+        const table = this._relatedSchemaThunk().table;
+        return this._db._findById(table, fk);
+    }
+    observe() {
+        const fk = this._getFkValue();
+        if (!fk) {
+            return {
+                subscribe: (listener) => {
+                    listener(null);
+                    return noop;
+                },
+            };
+        }
+        const table = this._relatedSchemaThunk().table;
+        return this._db._observeById(table, fk);
+    }
+}
+exports.BelongsToRelationImpl = BelongsToRelationImpl;
+// ─── HasManyRelationImpl ────────────────────────────────────────────────────
+class HasManyRelationImpl {
+    _ownerId;
+    _foreignKey;
+    _relatedSchemaThunk;
+    _db;
+    constructor(ownerId, foreignKey, relatedSchemaThunk, db) {
+        this._ownerId = ownerId;
+        this._foreignKey = foreignKey;
+        this._relatedSchemaThunk = relatedSchemaThunk;
+        this._db = db;
+    }
+    async fetch() {
+        const table = this._relatedSchemaThunk().table;
+        return this._db._fetchRelated(table, this._foreignKey, this._ownerId);
+    }
+    observe() {
+        const table = this._relatedSchemaThunk().table;
+        return this._db._observeRelated(table, this._foreignKey, this._ownerId);
+    }
+}
+exports.HasManyRelationImpl = HasManyRelationImpl;
+//# sourceMappingURL=Relation.js.map

package/dist/model/index.d.ts

@@ -1,2 +1,4 @@
 export { Model, createRawRecord } from './Model';
 export type { ModelStatic, ModelCollectionRef, ModelDatabaseRef } from './Model';
+export { BelongsToRelationImpl, HasManyRelationImpl } from './Relation';
+export type { RelationDatabaseRef } from './Relation';

package/dist/model/index.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRawRecord = exports.Model = void 0;
+exports.HasManyRelationImpl = exports.BelongsToRelationImpl = exports.createRawRecord = exports.Model = void 0;
 var Model_1 = require("./Model");
 Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return Model_1.Model; } });
 Object.defineProperty(exports, "createRawRecord", { enumerable: true, get: function () { return Model_1.createRawRecord; } });
+var Relation_1 = require("./Relation");
+Object.defineProperty(exports, "BelongsToRelationImpl", { enumerable: true, get: function () { return Relation_1.BelongsToRelationImpl; } });
+Object.defineProperty(exports, "HasManyRelationImpl", { enumerable: true, get: function () { return Relation_1.HasManyRelationImpl; } });
 //# sourceMappingURL=index.js.map

package/dist/schema/builder.d.ts

@@ -10,8 +10,8 @@
  *     body: m.text(),
  *     isPinned: m.boolean().default(false),
  *     createdAt: m.date('created_at').readonly(),
- *     author: m.belongsTo('users', { key: 'author_id' }),
- *     comments: m.hasMany('comments', { foreignKey: 'post_id' }),
+ *     author: m.belongsTo(() => UserSchema, { key: 'author_id' }),
+ *     comments: m.hasMany(() => CommentSchema, { foreignKey: 'post_id' }),
  *   });
  */
 import type { ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, ModelSchema, FieldDescriptor } from './types';
@@ -50,13 +50,13 @@ export declare const m: {
     /** Date column (stored as epoch ms in the database) */
     date(columnName?: string): ColumnBuilder<DateColumn>;
     /** Belongs-to relation (many-to-one). Adds a foreign key column. */
-    belongsTo(relatedTable: string, opts: {
+    belongsTo<S extends ModelSchema>(relatedSchema: () => S, opts: {
         key: string;
-    }): BelongsToDescriptor;
+    }): BelongsToDescriptor<S>;
     /** Has-many relation (one-to-many). Query-only, no stored column. */
-    hasMany(relatedTable: string, opts: {
+    hasMany<S extends ModelSchema>(relatedSchema: () => S, opts: {
         foreignKey: string;
-    }): HasManyDescriptor;
+    }): HasManyDescriptor<S>;
     /**
      * Define a model schema for the given table.
      *

package/dist/schema/builder.js

@@ -11,8 +11,8 @@
  *     body: m.text(),
  *     isPinned: m.boolean().default(false),
  *     createdAt: m.date('created_at').readonly(),
- *     author: m.belongsTo('users', { key: 'author_id' }),
- *     comments: m.hasMany('comments', { foreignKey: 'post_id' }),
+ *     author: m.belongsTo(() => UserSchema, { key: 'author_id' }),
+ *     comments: m.hasMany(() => CommentSchema, { foreignKey: 'post_id' }),
  *   });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -71,8 +71,8 @@ function resolveField(fieldName, raw) {
         const rel = {
             fieldName,
             kind: desc.kind,
-            relatedTable: desc.relatedTable,
             foreignKey: desc.foreignKey,
+            _relatedSchemaThunk: desc._relatedSchemaThunk,
         };
         // belongs_to also implies a column for the foreign key
         if (desc.kind === 'belongs_to') {
@@ -122,19 +122,19 @@ exports.m = {
         return makeColumn('date', columnName ?? null);
     },
     /** Belongs-to relation (many-to-one). Adds a foreign key column. */
-    belongsTo(relatedTable, opts) {
+    belongsTo(relatedSchema, opts) {
         return Object.freeze({
             kind: 'belongs_to',
-            relatedTable,
             foreignKey: opts.key,
+            _relatedSchemaThunk: relatedSchema,
         });
     },
     /** Has-many relation (one-to-many). Query-only, no stored column. */
-    hasMany(relatedTable, opts) {
+    hasMany(relatedSchema, opts) {
         return Object.freeze({
             kind: 'has_many',
-            relatedTable,
             foreignKey: opts.foreignKey,
+            _relatedSchemaThunk: relatedSchema,
         });
     },
     /**

package/dist/schema/index.d.ts

@@ -1,2 +1,2 @@
 export { m, ColumnBuilder } from './builder';
-export type { ColumnType, ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, RelationDescriptor, FieldDescriptor, SchemaFields, ModelSchema, ResolvedColumn, ResolvedRelation, DatabaseSchema, TableSchema, TableColumnSchema, SyncStatus, SyncColumns, RawRecord, InferColumnType, InferField, InferCreatePatch, InferUpdatePatch, InferRecord, } from './types';
+export type { ColumnType, ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, RelationDescriptor, FieldDescriptor, SchemaFields, ModelSchema, ResolvedColumn, ResolvedRelation, DatabaseSchema, TableSchema, TableColumnSchema, SyncStatus, SyncColumns, RawRecord, InferColumnType, InferField, InferCreatePatch, InferUpdatePatch, InferRecord, BelongsToRelation, HasManyRelation, ModelInstance, } from './types';

package/dist/schema/types.d.ts

@@ -26,15 +26,26 @@ export interface DateColumn extends ColumnDescriptor {
     readonly type: 'date';
 }
 export type RelationType = 'belongs_to' | 'has_many';
-export interface BelongsToDescriptor {
+/**
+ * Belongs-to (many-to-one) relation descriptor.
+ * Generic over the related ModelSchema so TypeScript can infer the related type.
+ * The thunk `_relatedSchemaThunk` is resolved lazily to support forward references.
+ */
+export interface BelongsToDescriptor<S extends ModelSchema = ModelSchema> {
     readonly kind: 'belongs_to';
-    readonly relatedTable: string;
     readonly foreignKey: string;
+    /** @internal Lazy reference to the related schema — supports forward references */
+    readonly _relatedSchemaThunk: () => S;
 }
-export interface HasManyDescriptor {
+/**
+ * Has-many (one-to-many) relation descriptor.
+ * Generic over the related ModelSchema so TypeScript can infer the related type.
+ */
+export interface HasManyDescriptor<S extends ModelSchema = ModelSchema> {
     readonly kind: 'has_many';
-    readonly relatedTable: string;
     readonly foreignKey: string;
+    /** @internal Lazy reference to the related schema — supports forward references */
+    readonly _relatedSchemaThunk: () => S;
 }
 export type RelationDescriptor = BelongsToDescriptor | HasManyDescriptor;
 export type FieldDescriptor = ColumnDescriptor | RelationDescriptor;
@@ -59,8 +70,9 @@ export interface ResolvedColumn {
 export interface ResolvedRelation {
     readonly fieldName: string;
     readonly kind: RelationType;
-    readonly relatedTable: string;
     readonly foreignKey: string;
+    /** @internal Lazy reference — call to get the related schema's table name */
+    readonly _relatedSchemaThunk: () => ModelSchema;
 }
 export interface DatabaseSchema {
     readonly version: number;
@@ -76,19 +88,46 @@ export interface TableColumnSchema {
     readonly isOptional: boolean;
     readonly isIndexed: boolean;
 }
+import type { Observable } from '../observable/Subject';
+/** Lazy belongs-to relation handle (many-to-one). */
+export interface BelongsToRelation<S extends ModelSchema = ModelSchema> {
+    /** The foreign key value (the related record's ID) */
+    readonly id: string | null;
+    /** Fetch the related record */
+    fetch(): Promise<ModelInstance<S> | null>;
+    /** Observe the related record reactively */
+    observe(): Observable<ModelInstance<S> | null>;
+}
+/** Lazy has-many relation handle (one-to-many). */
+export interface HasManyRelation<S extends ModelSchema = ModelSchema> {
+    /** Fetch all related records */
+    fetch(): Promise<ModelInstance<S>[]>;
+    /** Observe the related records reactively */
+    observe(): Observable<ModelInstance<S>[]>;
+}
+/**
+ * A model instance typed by its schema.
+ * Forward-declared as a minimal interface to avoid circular imports.
+ * Full Model class satisfies this at runtime.
+ */
+export interface ModelInstance<S extends ModelSchema = ModelSchema> {
+    readonly id: string;
+    getField(fieldName: string): unknown;
+    observe(): Observable<ModelInstance<S>>;
+}
 /** Infer the runtime TypeScript type from a ColumnDescriptor */
 export type InferColumnType<C extends ColumnDescriptor> = C['type'] extends 'text' ? string : C['type'] extends 'number' ? number : C['type'] extends 'boolean' ? boolean : C['type'] extends 'date' ? Date : never;
 /** For optional columns, make the type T | null */
 type MaybeOptional<C extends ColumnDescriptor, T> = C['isOptional'] extends true ? T | null : T;
-/** Infer column type respecting optionality */
-export type InferField<C extends FieldDescriptor> = C extends ColumnDescriptor ? MaybeOptional<C, InferColumnType<C>> : C extends BelongsToDescriptor ? string : C extends HasManyDescriptor ? never : never;
+/** Infer field type — columns resolve to values, relations resolve to relation wrappers */
+export type InferField<C extends FieldDescriptor> = C extends ColumnDescriptor ? MaybeOptional<C, InferColumnType<C>> : C extends BelongsToDescriptor<infer S> ? BelongsToRelation<S> : C extends HasManyDescriptor<infer S> ? HasManyRelation<S> : never;
 /** The record shape inferred from schema fields (writable columns only) */
 export type InferCreatePatch<F extends SchemaFields> = {
     [K in keyof F as F[K] extends ColumnDescriptor ? F[K]['isReadonly'] extends true ? never : K : F[K] extends BelongsToDescriptor ? K : never]: F[K] extends ColumnDescriptor ? MaybeOptional<F[K], InferColumnType<F[K]>> : F[K] extends BelongsToDescriptor ? string : never;
 };
 /** The record shape for updates — all writable fields optional */
 export type InferUpdatePatch<F extends SchemaFields> = Partial<InferCreatePatch<F>>;
-/** Full record shape (all columns + belongs_to keys) */
+/** Full record shape (all columns + relation wrappers) */
 export type InferRecord<F extends SchemaFields> = {
     readonly id: string;
 } & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pomegranate-db",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Reactive offline-first database with sync support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -62,6 +62,7 @@
     "build": "tsc && tsc -p expo-plugin/tsconfig.json",
     "build:lib": "tsc",
     "build:expo-plugin": "tsc -p expo-plugin/tsconfig.json",
+    "pack:demo": "./scripts/pack-demo-tarball",
     "prepack": "npm run clean && npm run build",
     "test": "jest",
     "test:web": "jest --testPathPattern='web\\.test' --no-cache",