@hammr/do-orm 1.0.0

package/README.md

@@ -0,0 +1,560 @@
+# DO-ORM
+
+**Type-safe ORM for Cloudflare Durable Objects with zero runtime overhead**
+
+DO-ORM makes Durable Objects queryable like a real database while maintaining the performance and simplicity of Cloudflare's storage API. Built with pure TypeScript, zero dependencies, and automatic schema validation.
+
+## Features
+
+✅ **Type-safe schema definitions** - Full TypeScript inference for all CRUD operations  
+✅ **Automatic validation** - Schema validation on every write operation  
+✅ **Efficient indexing** - Single-field indexes for O(log n) queries instead of O(n) scans  
+✅ **Fluent query builder** - Chain `.where()`, `.after()`, `.before()`, `.limit()`, `.orderBy()`  
+✅ **Full CRUD support** - `create()`, `find()`, `update()`, `delete()`, and bulk operations  
+✅ **Zero dependencies** - Pure TypeScript using DO storage primitives  
+✅ **Zero runtime overhead** - Direct wrapper around Durable Objects storage API  
+
+## Installation
+
+```bash
+npm install @hammr/do-orm
+```
+
+## Quick Start
+
+### 1. Define your model
+
+```typescript
+import { DOModel, SchemaDefinition, InferSchemaType } from '@hammr/do-orm';
+
+// Define schema with type annotations
+interface EventSchema extends SchemaDefinition {
+  id: 'string';
+  workspaceId: 'string';
+  timestamp: 'date';
+  type: 'string';
+  data: 'object';
+}
+
+// Create model class
+class Event extends DOModel<EventSchema> {
+  protected schema: EventSchema = {
+    id: 'string',
+    workspaceId: 'string',
+    timestamp: 'date',
+    type: 'string',
+    data: 'object',
+  };
+  
+  // Define indexes for efficient queries
+  protected indexes = ['workspaceId', 'timestamp'] as const;
+}
+```
+
+### 2. Use in your Durable Object
+
+```typescript
+export class MyDurableObject {
+  private eventModel: Event;
+
+  constructor(state: DurableObjectState) {
+    this.eventModel = new Event(state.storage);
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    // Create an event
+    const event = await this.eventModel.create({
+      id: 'evt_123',
+      workspaceId: 'ws_abc',
+      timestamp: new Date(),
+      type: 'click',
+      data: { button: 'submit' }
+    });
+
+    // Query events
+    const recentEvents = await this.eventModel
+      .where({ workspaceId: 'ws_abc' })
+      .after(new Date('2024-01-01'))
+      .limit(100)
+      .orderBy('timestamp', 'desc')
+      .execute();
+
+    return new Response(JSON.stringify(recentEvents));
+  }
+}
+```
+
+## API Reference
+
+### Schema Types
+
+DO-ORM supports the following field types:
+
+- `'string'` - String values
+- `'number'` - Numeric values (integers and floats)
+- `'boolean'` - Boolean values (true/false)
+- `'date'` - Date objects (automatically serialized/deserialized)
+- `'object'` - Plain JavaScript objects
+- `'array'` - Arrays of any type
+
+### CRUD Operations
+
+#### `create(data: T): Promise<T>`
+
+Create a new record. Throws if validation fails or ID already exists.
+
+```typescript
+const event = await eventModel.create({
+  id: 'evt_1',
+  workspaceId: 'ws_abc',
+  timestamp: new Date(),
+  type: 'pageview',
+  data: { page: '/home' }
+});
+```
+
+#### `find(id: string): Promise<T | null>`
+
+Find a record by ID. Returns `null` if not found.
+
+```typescript
+const event = await eventModel.find('evt_1');
+if (event) {
+  console.log(event.type); // Type-safe access
+}
+```
+
+#### `update(id: string, updates: Partial<T>): Promise<T>`
+
+Update a record with partial data. Validates the complete merged record.
+
+```typescript
+const updated = await eventModel.update('evt_1', {
+  data: { page: '/about' }
+});
+```
+
+#### `delete(id: string): Promise<boolean>`
+
+Delete a record by ID. Returns `true` if deleted, `false` if not found.
+
+```typescript
+const deleted = await eventModel.delete('evt_1');
+```
+
+#### `all(): Promise<T[]>`
+
+Get all records (unfiltered).
+
+```typescript
+const allEvents = await eventModel.all();
+```
+
+#### `count(): Promise<number>`
+
+Count all records.
+
+```typescript
+const totalEvents = await eventModel.count();
+```
+
+### Query Builder
+
+Chain query methods for powerful filtering and sorting:
+
+#### `where(conditions: Partial<T>): QueryBuilder<T>`
+
+Filter by field values. Uses indexes when available.
+
+```typescript
+const events = await eventModel
+  .where({ workspaceId: 'ws_abc' })
+  .execute();
+```
+
+#### `after(date: Date): QueryBuilder<T>`
+
+Filter records with date fields after the specified date.
+
+```typescript
+const recentEvents = await eventModel
+  .after(new Date('2024-01-01'))
+  .execute();
+```
+
+#### `before(date: Date): QueryBuilder<T>`
+
+Filter records with date fields before the specified date.
+
+```typescript
+const oldEvents = await eventModel
+  .before(new Date('2023-12-31'))
+  .execute();
+```
+
+#### `limit(count: number): QueryBuilder<T>`
+
+Limit the number of results returned.
+
+```typescript
+const topEvents = await eventModel
+  .where({ workspaceId: 'ws_abc' })
+  .limit(10)
+  .execute();
+```
+
+#### `orderBy(field: keyof T, direction: 'asc' | 'desc'): QueryBuilder<T>`
+
+Sort results by a field.
+
+```typescript
+const sortedEvents = await eventModel
+  .where({ workspaceId: 'ws_abc' })
+  .orderBy('timestamp', 'desc')
+  .execute();
+```
+
+#### `execute(): Promise<T[]>`
+
+Execute the query and return results.
+
+```typescript
+const events = await eventModel
+  .where({ workspaceId: 'ws_abc' })
+  .limit(100)
+  .execute();
+```
+
+### Query Chaining Example
+
+```typescript
+const events = await eventModel
+  .where({ workspaceId: 'ws_abc' })
+  .after(new Date('2024-01-01'))
+  .before(new Date('2024-12-31'))
+  .orderBy('timestamp', 'desc')
+  .limit(50)
+  .execute();
+```
+
+## Indexing
+
+Indexes dramatically improve query performance by avoiding full table scans:
+
+- **Without index**: O(n) - scans every record
+- **With index**: O(log n) - uses sorted index lookup
+
+### How to define indexes
+
+```typescript
+class Event extends DOModel<EventSchema> {
+  protected schema: EventSchema = {
+    id: 'string',
+    workspaceId: 'string',
+    timestamp: 'date',
+    type: 'string',
+  };
+  
+  // Index these fields for efficient queries
+  protected indexes = ['workspaceId', 'timestamp'] as const;
+}
+```
+
+### When queries use indexes
+
+- `.where({ indexedField: value })` - Uses index if first field is indexed
+- Without indexed where clause - Falls back to full scan
+
+### Index maintenance
+
+Indexes are automatically maintained:
+- Created during `create()`
+- Updated during `update()` (if indexed fields change)
+- Removed during `delete()`
+
+## Schema Validation
+
+DO-ORM validates all data against your schema:
+
+```typescript
+// ✅ Valid - passes validation
+await eventModel.create({
+  id: 'evt_1',
+  workspaceId: 'ws_abc',
+  timestamp: new Date(),
+  type: 'click',
+  data: {}
+});
+
+// ❌ Invalid - throws error
+await eventModel.create({
+  id: 'evt_1',
+  workspaceId: 123, // Error: must be string
+  timestamp: new Date(),
+  type: 'click',
+  data: {}
+});
+
+// ❌ Invalid - throws error
+await eventModel.create({
+  id: 'evt_1',
+  // Missing required fields
+});
+```
+
+### Validation errors
+
+```typescript
+try {
+  await eventModel.create(invalidData);
+} catch (error) {
+  // "Field 'workspaceId' must be a string, got number"
+  // "Missing required field: timestamp"
+}
+```
+
+## TypeScript Inference
+
+DO-ORM provides full type inference:
+
+```typescript
+// Define schema
+interface EventSchema extends SchemaDefinition {
+  id: 'string';
+  workspaceId: 'string';
+  timestamp: 'date';
+}
+
+class Event extends DOModel<EventSchema> {
+  protected schema: EventSchema = {
+    id: 'string',
+    workspaceId: 'string',
+    timestamp: 'date',
+  };
+  protected indexes = ['workspaceId'] as const;
+}
+
+// TypeScript knows the exact type!
+const event = await eventModel.find('evt_1');
+//    ^? Event | null
+
+if (event) {
+  event.id;           // string
+  event.workspaceId;  // string
+  event.timestamp;    // Date
+  event.unknown;      // ❌ TypeScript error
+}
+```
+
+## Advanced Usage
+
+### Custom table names
+
+```typescript
+class Event extends DOModel<EventSchema> {
+  constructor(storage: DurableObjectStorage) {
+    super(storage, 'custom_events_table');
+  }
+  
+  protected schema: EventSchema = { /* ... */ };
+  protected indexes = [] as const;
+}
+```
+
+### Multiple models in one DO
+
+```typescript
+export class MyDurableObject {
+  private events: Event;
+  private users: User;
+
+  constructor(state: DurableObjectState) {
+    this.events = new Event(state.storage);
+    this.users = new User(state.storage, 'users_table');
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    const event = await this.events.find('evt_1');
+    const user = await this.users.find('user_1');
+    // ...
+  }
+}
+```
+
+## Performance Considerations
+
+### Index usage
+
+- **Indexed queries**: Fast O(log n) lookups
+- **Non-indexed queries**: Slower O(n) full scans
+- **Best practice**: Index frequently queried fields
+
+### Storage efficiency
+
+- Records stored as: `{tableName}:{id}`
+- Indexes stored as: `index:{tableName}:{field}:{value}`
+- Dates serialized as ISO strings for efficient sorting
+
+### Query optimization tips
+
+1. **Use indexes** - Define indexes for frequently queried fields
+2. **Limit results** - Always use `.limit()` for large datasets
+3. **Specific where clauses** - Filter by indexed fields first
+4. **Batch operations** - Consider batching writes for bulk inserts
+
+## Limitations
+
+- **No compound indexes** - Only single-field indexes (for now)
+- **No transactions** - Each operation is atomic but not grouped
+- **No joins** - Each model is independent
+- **No migrations** - Schema changes require manual data migration
+
+## Examples
+
+### Analytics events tracker
+
+```typescript
+interface AnalyticsSchema extends SchemaDefinition {
+  id: 'string';
+  sessionId: 'string';
+  userId: 'string';
+  event: 'string';
+  timestamp: 'date';
+  properties: 'object';
+}
+
+class Analytics extends DOModel<AnalyticsSchema> {
+  protected schema: AnalyticsSchema = {
+    id: 'string',
+    sessionId: 'string',
+    userId: 'string',
+    event: 'string',
+    timestamp: 'date',
+    properties: 'object',
+  };
+  
+  protected indexes = ['userId', 'sessionId', 'timestamp'] as const;
+}
+
+// Track an event
+await analytics.create({
+  id: generateId(),
+  sessionId: 'session_abc',
+  userId: 'user_123',
+  event: 'purchase',
+  timestamp: new Date(),
+  properties: { amount: 99.99, currency: 'USD' }
+});
+
+// Get user's recent events
+const userEvents = await analytics
+  .where({ userId: 'user_123' })
+  .after(thirtyDaysAgo)
+  .orderBy('timestamp', 'desc')
+  .limit(100)
+  .execute();
+```
+
+### Task queue
+
+```typescript
+interface TaskSchema extends SchemaDefinition {
+  id: 'string';
+  status: 'string';
+  priority: 'number';
+  createdAt: 'date';
+  payload: 'object';
+}
+
+class Task extends DOModel<TaskSchema> {
+  protected schema: TaskSchema = {
+    id: 'string',
+    status: 'string',
+    priority: 'number',
+    createdAt: 'date',
+    payload: 'object',
+  };
+  
+  protected indexes = ['status', 'priority'] as const;
+}
+
+// Add task
+await task.create({
+  id: 'task_1',
+  status: 'pending',
+  priority: 1,
+  createdAt: new Date(),
+  payload: { action: 'send_email' }
+});
+
+// Get pending tasks
+const pending = await task
+  .where({ status: 'pending' })
+  .orderBy('priority', 'asc')
+  .limit(10)
+  .execute();
+
+// Process and mark complete
+for (const t of pending) {
+  await processTask(t);
+  await task.update(t.id, { status: 'completed' });
+}
+```
+
+## Testing
+
+### Unit Tests
+
+Run the unit test suite:
+
+```bash
+npm test
+```
+
+Tests include:
+- Schema validation (type checking, required fields)
+- CRUD operations (create, read, update, delete)
+- Query builder (where, limit, orderBy, date ranges)
+- Index usage and maintenance
+- Edge cases (duplicates, missing records)
+
+### Integration Tests (with Cloudflare Workers)
+
+Test the ORM in a real Cloudflare Workers environment:
+
+```bash
+# Terminal 1: Start the worker
+npm run dev
+
+# Terminal 2: Run integration tests
+npm run test:worker
+```
+
+The integration tests verify the complete stack:
+- Worker HTTP endpoints
+- Durable Object instantiation
+- DO-ORM with real DO storage
+- Schema validation in production
+- Query performance with indexes
+
+See [TESTING.md](./TESTING.md) for more details on testing with Cloudflare Workers.
+
+## Contributing
+
+This is v1 - there's lots of room for improvement!
+
+**Potential enhancements:**
+- Compound indexes (multiple fields)
+- Transactions support
+- Query result streaming
+- Migration helpers
+- Soft deletes
+- Hooks (beforeCreate, afterUpdate, etc.)
+
+## License
+
+MIT
+
+---
+
+Built for the Cloudflare Workers ecosystem. Works seamlessly with Durable Objects and provides a better developer experience than raw storage API calls.

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * DO-ORM v1 - Type-safe ORM for Cloudflare Durable Objects
+ * Zero dependencies, pure TypeScript implementation
+ */
+import type { SchemaDefinition, QueryOptions, InferSchemaType } from './types';
+export * from './types';
+/**
+ * Base class for all DO models
+ * Provides CRUD operations, schema validation, and indexing
+ */
+export declare abstract class DOModel<S extends SchemaDefinition> {
+    protected abstract schema: S;
+    protected abstract indexes: (keyof InferSchemaType<S>)[];
+    protected storage: DurableObjectStorage;
+    protected tableName: string;
+    constructor(storage: DurableObjectStorage, tableName?: string);
+    /**
+     * Validate a value against a schema field type
+     */
+    private validateField;
+    /**
+     * Validate an entire record against the schema
+     */
+    private validateSchema;
+    /**
+     * Generate storage key for a record
+     */
+    private getRecordKey;
+    /**
+     * Generate storage key for an index
+     */
+    private getIndexKey;
+    /**
+     * Get all index entry keys for a given field
+     */
+    private getIndexPrefix;
+    /**
+     * Serialize a value for storage (convert Dates to ISO strings)
+     */
+    private serialize;
+    /**
+     * Deserialize a value from storage (convert ISO strings back to Dates)
+     */
+    private deserialize;
+    /**
+     * Update indexes for a record
+     */
+    private updateIndexes;
+    /**
+     * Remove record ID from indexes
+     */
+    private removeFromIndexes;
+    /**
+     * Create a new record
+     */
+    create(data: InferSchemaType<S>): Promise<InferSchemaType<S>>;
+    /**
+     * Find a record by ID
+     */
+    find(id: string): Promise<InferSchemaType<S> | null>;
+    /**
+     * Update a record
+     */
+    update(id: string, updates: Partial<InferSchemaType<S>>): Promise<InferSchemaType<S>>;
+    /**
+     * Delete a record
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Query builder - returns all matching records
+     */
+    query(options?: QueryOptions<InferSchemaType<S>>): Promise<InferSchemaType<S>[]>;
+    /**
+     * Query builder with fluent API
+     */
+    where(conditions: Partial<InferSchemaType<S>>): QueryBuilder<S>;
+    /**
+     * Get all records
+     */
+    all(): Promise<InferSchemaType<S>[]>;
+    /**
+     * Count all records
+     */
+    count(): Promise<number>;
+}
+/**
+ * Fluent query builder
+ */
+export declare class QueryBuilder<S extends SchemaDefinition> {
+    private model;
+    private options;
+    constructor(model: DOModel<S>, options?: QueryOptions<InferSchemaType<S>>);
+    where(conditions: Partial<InferSchemaType<S>>): QueryBuilder<S>;
+    after(date: Date): QueryBuilder<S>;
+    before(date: Date): QueryBuilder<S>;
+    limit(count: number): QueryBuilder<S>;
+    orderBy(field: keyof InferSchemaType<S>, direction?: 'asc' | 'desc'): QueryBuilder<S>;
+    execute(): Promise<InferSchemaType<S>[]>;
+}

package/dist/index.js

@@ -0,0 +1,358 @@
+/**
+ * DO-ORM v1 - Type-safe ORM for Cloudflare Durable Objects
+ * Zero dependencies, pure TypeScript implementation
+ */
+export * from './types';
+/**
+ * Base class for all DO models
+ * Provides CRUD operations, schema validation, and indexing
+ */
+export class DOModel {
+    constructor(storage, tableName) {
+        this.storage = storage;
+        this.tableName = tableName || this.constructor.name.toLowerCase();
+    }
+    /**
+     * Validate a value against a schema field type
+     */
+    validateField(value, fieldType, fieldName) {
+        switch (fieldType) {
+            case 'string':
+                if (typeof value !== 'string') {
+                    throw new Error(`Field '${fieldName}' must be a string, got ${typeof value}`);
+                }
+                break;
+            case 'number':
+                if (typeof value !== 'number' || isNaN(value)) {
+                    throw new Error(`Field '${fieldName}' must be a number, got ${typeof value}`);
+                }
+                break;
+            case 'boolean':
+                if (typeof value !== 'boolean') {
+                    throw new Error(`Field '${fieldName}' must be a boolean, got ${typeof value}`);
+                }
+                break;
+            case 'date':
+                if (!(value instanceof Date) || isNaN(value.getTime())) {
+                    throw new Error(`Field '${fieldName}' must be a valid Date, got ${typeof value}`);
+                }
+                break;
+            case 'object':
+                if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                    throw new Error(`Field '${fieldName}' must be an object, got ${typeof value}`);
+                }
+                break;
+            case 'array':
+                if (!Array.isArray(value)) {
+                    throw new Error(`Field '${fieldName}' must be an array, got ${typeof value}`);
+                }
+                break;
+            default:
+                throw new Error(`Unknown field type: ${fieldType}`);
+        }
+    }
+    /**
+     * Validate an entire record against the schema
+     */
+    validateSchema(data) {
+        // Check for missing required fields
+        for (const [fieldName, fieldType] of Object.entries(this.schema)) {
+            if (!(fieldName in data)) {
+                throw new Error(`Missing required field: ${fieldName}`);
+            }
+            this.validateField(data[fieldName], fieldType, fieldName);
+        }
+    }
+    /**
+     * Generate storage key for a record
+     */
+    getRecordKey(id) {
+        return `${this.tableName}:${id}`;
+    }
+    /**
+     * Generate storage key for an index
+     */
+    getIndexKey(field, value) {
+        const normalizedValue = value instanceof Date ? value.toISOString() : String(value);
+        return `index:${this.tableName}:${field}:${normalizedValue}`;
+    }
+    /**
+     * Get all index entry keys for a given field
+     */
+    getIndexPrefix(field) {
+        return `index:${this.tableName}:${field}:`;
+    }
+    /**
+     * Serialize a value for storage (convert Dates to ISO strings)
+     */
+    serialize(data) {
+        const serialized = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value instanceof Date) {
+                serialized[key] = value.toISOString();
+            }
+            else {
+                serialized[key] = value;
+            }
+        }
+        return serialized;
+    }
+    /**
+     * Deserialize a value from storage (convert ISO strings back to Dates)
+     */
+    deserialize(data) {
+        const deserialized = {};
+        for (const [key, value] of Object.entries(data)) {
+            const fieldType = this.schema[key];
+            if (fieldType === 'date' && typeof value === 'string') {
+                deserialized[key] = new Date(value);
+            }
+            else {
+                deserialized[key] = value;
+            }
+        }
+        return deserialized;
+    }
+    /**
+     * Update indexes for a record
+     */
+    async updateIndexes(id, data) {
+        for (const indexField of this.indexes) {
+            const fieldValue = data[indexField];
+            const indexKey = this.getIndexKey(String(indexField), fieldValue);
+            // Get existing IDs in this index
+            const existingIds = await this.storage.get(indexKey) || [];
+            // Add ID if not already present
+            if (!existingIds.includes(id)) {
+                existingIds.push(id);
+                await this.storage.put(indexKey, existingIds);
+            }
+        }
+    }
+    /**
+     * Remove record ID from indexes
+     */
+    async removeFromIndexes(id, data) {
+        for (const indexField of this.indexes) {
+            const fieldValue = data[indexField];
+            const indexKey = this.getIndexKey(String(indexField), fieldValue);
+            // Get existing IDs and remove this one
+            const existingIds = await this.storage.get(indexKey) || [];
+            const filteredIds = existingIds.filter(existingId => existingId !== id);
+            if (filteredIds.length > 0) {
+                await this.storage.put(indexKey, filteredIds);
+            }
+            else {
+                await this.storage.delete(indexKey);
+            }
+        }
+    }
+    /**
+     * Create a new record
+     */
+    async create(data) {
+        // Validate schema
+        this.validateSchema(data);
+        // Check if record already exists
+        const id = data.id;
+        if (!id) {
+            throw new Error('Record must have an id field');
+        }
+        const key = this.getRecordKey(id);
+        const existing = await this.storage.get(key);
+        if (existing) {
+            throw new Error(`Record with id '${id}' already exists`);
+        }
+        // Serialize and store
+        const serialized = this.serialize(data);
+        await this.storage.put(key, serialized);
+        // Update indexes
+        await this.updateIndexes(id, data);
+        return data;
+    }
+    /**
+     * Find a record by ID
+     */
+    async find(id) {
+        const key = this.getRecordKey(id);
+        const data = await this.storage.get(key);
+        if (!data) {
+            return null;
+        }
+        return this.deserialize(data);
+    }
+    /**
+     * Update a record
+     */
+    async update(id, updates) {
+        const existing = await this.find(id);
+        if (!existing) {
+            throw new Error(`Record with id '${id}' not found`);
+        }
+        // Merge updates
+        const updated = { ...existing, ...updates };
+        // Validate the complete record
+        this.validateSchema(updated);
+        // Remove old indexes if indexed fields changed
+        const indexedFieldsChanged = this.indexes.some(field => field in updates && updates[field] !== existing[field]);
+        if (indexedFieldsChanged) {
+            await this.removeFromIndexes(id, existing);
+        }
+        // Store updated record
+        const serialized = this.serialize(updated);
+        await this.storage.put(this.getRecordKey(id), serialized);
+        // Update indexes with new values
+        if (indexedFieldsChanged) {
+            await this.updateIndexes(id, updated);
+        }
+        return updated;
+    }
+    /**
+     * Delete a record
+     */
+    async delete(id) {
+        const existing = await this.find(id);
+        if (!existing) {
+            return false;
+        }
+        // Remove from indexes
+        await this.removeFromIndexes(id, existing);
+        // Delete record
+        await this.storage.delete(this.getRecordKey(id));
+        return true;
+    }
+    /**
+     * Query builder - returns all matching records
+     */
+    async query(options = {}) {
+        let candidateIds = [];
+        // Use indexes if where clause matches an indexed field
+        if (options.where) {
+            const whereEntries = Object.entries(options.where);
+            if (whereEntries.length > 0) {
+                const [field, value] = whereEntries[0];
+                // Check if this field is indexed
+                if (this.indexes.includes(field)) {
+                    const indexKey = this.getIndexKey(field, value);
+                    candidateIds = await this.storage.get(indexKey) || [];
+                }
+            }
+        }
+        // If no index was used, scan all records (slower)
+        if (candidateIds.length === 0 && !options.where) {
+            const prefix = `${this.tableName}:`;
+            const allKeys = await this.storage.list({ prefix });
+            candidateIds = Array.from(allKeys.keys()).map(key => key.toString().replace(prefix, ''));
+        }
+        // Load all candidate records
+        const records = [];
+        for (const id of candidateIds) {
+            const record = await this.find(id);
+            if (record) {
+                records.push(record);
+            }
+        }
+        // Apply filters
+        let filtered = records;
+        // Filter by where clause (additional fields not covered by index)
+        if (options.where) {
+            filtered = filtered.filter(record => {
+                for (const [key, value] of Object.entries(options.where)) {
+                    if (record[key] !== value) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+        // Filter by date range (after/before)
+        if (options.after || options.before) {
+            filtered = filtered.filter(record => {
+                // Find date field in schema
+                for (const [field, type] of Object.entries(this.schema)) {
+                    if (type === 'date') {
+                        const dateValue = record[field];
+                        if (dateValue instanceof Date) {
+                            if (options.after && dateValue <= options.after)
+                                return false;
+                            if (options.before && dateValue >= options.before)
+                                return false;
+                        }
+                    }
+                }
+                return true;
+            });
+        }
+        // Sort
+        if (options.orderBy) {
+            const { field, direction } = options.orderBy;
+            filtered.sort((a, b) => {
+                const aVal = a[field];
+                const bVal = b[field];
+                let comparison = 0;
+                if (aVal < bVal)
+                    comparison = -1;
+                if (aVal > bVal)
+                    comparison = 1;
+                return direction === 'desc' ? -comparison : comparison;
+            });
+        }
+        // Apply limit
+        if (options.limit) {
+            filtered = filtered.slice(0, options.limit);
+        }
+        return filtered;
+    }
+    /**
+     * Query builder with fluent API
+     */
+    where(conditions) {
+        return new QueryBuilder(this, { where: conditions });
+    }
+    /**
+     * Get all records
+     */
+    async all() {
+        return this.query();
+    }
+    /**
+     * Count all records
+     */
+    async count() {
+        const prefix = `${this.tableName}:`;
+        const allKeys = await this.storage.list({ prefix });
+        return allKeys.size;
+    }
+}
+/**
+ * Fluent query builder
+ */
+export class QueryBuilder {
+    constructor(model, options = {}) {
+        this.model = model;
+        this.options = options;
+    }
+    where(conditions) {
+        this.options.where = { ...this.options.where, ...conditions };
+        return this;
+    }
+    after(date) {
+        this.options.after = date;
+        return this;
+    }
+    before(date) {
+        this.options.before = date;
+        return this;
+    }
+    limit(count) {
+        this.options.limit = count;
+        return this;
+    }
+    orderBy(field, direction = 'asc') {
+        this.options.orderBy = { field, direction };
+        return this;
+    }
+    async execute() {
+        return this.model.query(this.options);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Type definitions for DO-ORM
+ */
+export type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
+export interface SchemaDefinition {
+    [key: string]: FieldType;
+}
+export interface QueryOptions<T> {
+    where?: Partial<T>;
+    after?: Date;
+    before?: Date;
+    limit?: number;
+    orderBy?: {
+        field: keyof T;
+        direction: 'asc' | 'desc';
+    };
+}
+export interface ModelConfig {
+    tableName?: string;
+}
+export type InferSchemaType<S extends SchemaDefinition> = {
+    [K in keyof S]: S[K] extends 'string' ? string : S[K] extends 'number' ? number : S[K] extends 'boolean' ? boolean : S[K] extends 'date' ? Date : S[K] extends 'object' ? Record<string, any> : S[K] extends 'array' ? any[] : never;
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for DO-ORM
+ */
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@hammr/do-orm",
+  "version": "1.0.0",
+  "description": "Type-safe ORM for Cloudflare Durable Objects with zero runtime overhead",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "tsx test.ts",
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "test:worker": "tsx test-worker.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "orm",
+    "typescript",
+    "database",
+    "stateless"
+  ],
+  "author": "Edge Foundry, Inc.",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20231218.0",
+    "typescript": "^5.3.3",
+    "tsx": "^4.7.0",
+    "wrangler": "^3.78.0"
+  },
+  "peerDependencies": {
+    "@cloudflare/workers-types": ">=4.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}