@objectstack/driver-memory 0.6.1 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @objectstack/driver-memory
 
+## 0.7.2
+
+### Patch Changes
+
+- fb41cc0: Patch release: Updated documentation and JSON schemas
+- Updated dependencies [fb41cc0]
+  - @objectstack/spec@0.7.2
+  - @objectstack/core@0.7.2
+
+## 0.7.1
+
+### Patch Changes
+
+- Patch release for maintenance and stability improvements
+- Updated dependencies
+  - @objectstack/spec@0.7.1
+  - @objectstack/core@0.7.1
+
 ## 0.6.1
 
 ### Patch Changes

package/README.md

@@ -0,0 +1,227 @@
+# @objectstack/driver-memory
+
+In-Memory Driver for ObjectStack. A reference implementation of the DriverInterface that stores data in memory using JavaScript arrays.
+
+## Plugin Capabilities
+
+This driver implements the ObjectStack plugin capability protocol:
+- **Type**: `driver`
+- **Protocol**: `com.objectstack.protocol.storage.v1` (partial conformance)
+- **Provides**: `DriverInterface` for data storage operations
+- **Features**: 
+  - ✅ Basic CRUD operations
+  - ✅ Pagination (limit/offset)
+  - ❌ Advanced query filters
+  - ❌ Aggregations
+  - ❌ Sorting
+  - ❌ Transactions
+  - ❌ Joins
+
+See [objectstack.config.ts](./objectstack.config.ts) for the complete capability manifest.
+
+## Features
+
+- 🚀 **Zero Dependencies**: Pure JavaScript implementation
+- 🧪 **Perfect for Testing**: Volatile storage ideal for unit tests
+- 📝 **TypeScript First**: Fully typed with TypeScript
+- 🔍 **Reference Implementation**: Clean example of DriverInterface
+- ⚡ **Fast**: In-memory operations are lightning fast
+
+## Installation
+
+```bash
+pnpm add @objectstack/driver-memory
+```
+
+## Usage
+
+### With ObjectStack Runtime
+
+```typescript
+import { InMemoryDriver } from '@objectstack/driver-memory';
+import { DriverPlugin } from '@objectstack/runtime';
+import { ObjectKernel } from '@objectstack/runtime';
+
+const kernel = new ObjectKernel();
+
+// Create and register the driver
+const memoryDriver = new InMemoryDriver();
+kernel.use(new DriverPlugin(memoryDriver, 'memory'));
+
+await kernel.bootstrap();
+```
+
+### Standalone Usage
+
+```typescript
+import { InMemoryDriver } from '@objectstack/driver-memory';
+
+const driver = new InMemoryDriver({
+  seedData: true  // Pre-populate with example data
+});
+
+// Initialize
+await driver.connect();
+
+// Create a record
+const user = await driver.create('user', {
+  name: 'John Doe',
+  email: 'john@example.com'
+});
+
+// Find records
+const users = await driver.find('user', {
+  limit: 10,
+  offset: 0
+});
+
+// Get by ID
+const foundUser = await driver.findOne('user', user.id);
+
+// Update
+await driver.update('user', user.id, {
+  name: 'Jane Doe'
+});
+
+// Delete
+await driver.delete('user', user.id);
+
+// Count
+const count = await driver.count('user');
+
+// Cleanup
+await driver.disconnect();
+```
+
+## API Reference
+
+### InMemoryDriver
+
+The main driver class that implements `DriverInterface`.
+
+#### Constructor Options
+
+```typescript
+interface DriverOptions {
+  /**
+   * Pre-populate the database with example data on startup
+   * @default false
+   */
+  seedData?: boolean;
+  
+  /**
+   * Logger instance
+   */
+  logger?: Logger;
+}
+```
+
+#### Methods
+
+- `connect()` - Initialize the driver (no-op for in-memory)
+- `disconnect()` - Cleanup resources (clears all data)
+- `create(object, data)` - Create a new record
+- `find(object, query?)` - Query records with optional pagination
+- `findOne(object, id)` - Get a single record by ID
+- `update(object, id, data)` - Update a record
+- `delete(object, id)` - Delete a record
+- `count(object, query?)` - Count total records
+- `getSchema(object)` - Get object schema definition
+- `query(query)` - Execute a raw query (limited support)
+
+#### Capabilities
+
+The driver declares its capabilities via the `supports` property:
+
+```typescript
+{
+  transactions: false,
+  queryFilters: false,
+  queryAggregations: false,
+  querySorting: false,
+  queryPagination: true,  // ✅ Supported via limit/offset
+  queryWindowFunctions: false,
+  querySubqueries: false,
+  joins: false,
+  fullTextSearch: false,
+  vectorSearch: false,
+  geoSpatial: false
+}
+```
+
+## Data Storage
+
+The in-memory driver stores data in a simple Map structure:
+
+```typescript
+private tables: Map<string, Array<Record<string, any>>> = new Map();
+```
+
+**Important**: All data is lost when the process exits or `disconnect()` is called. This driver is **not suitable for production use**.
+
+## Use Cases
+
+✅ **Good for:**
+- Unit testing
+- Integration testing
+- Development/prototyping
+- CI/CD pipelines
+- Examples and tutorials
+- Learning ObjectStack
+
+❌ **Not suitable for:**
+- Production environments
+- Data persistence requirements
+- Large datasets (memory constraints)
+- Multi-process scenarios
+- Concurrent write operations
+
+## Testing Example
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { InMemoryDriver } from '@objectstack/driver-memory';
+
+describe('User CRUD', () => {
+  let driver: InMemoryDriver;
+
+  beforeEach(async () => {
+    driver = new InMemoryDriver();
+    await driver.connect();
+  });
+
+  afterEach(async () => {
+    await driver.disconnect();
+  });
+
+  it('should create and retrieve a user', async () => {
+    const user = await driver.create('user', {
+      name: 'Test User',
+      email: 'test@example.com'
+    });
+
+    expect(user.id).toBeDefined();
+    
+    const found = await driver.findOne('user', user.id);
+    expect(found.name).toBe('Test User');
+  });
+});
+```
+
+## Relationship to Other Drivers
+
+This driver serves as a reference implementation. For production use, consider:
+
+- **@objectstack/driver-postgres** - PostgreSQL driver with full SQL capabilities
+- **@objectstack/driver-mongodb** - MongoDB driver for document storage
+- **@objectstack/driver-redis** - Redis driver for caching and key-value storage
+
+## License
+
+Apache-2.0
+
+## Related Packages
+
+- [@objectstack/runtime](../../runtime) - ObjectStack Runtime
+- [@objectstack/spec](../../spec) - ObjectStack Specifications
+- [@objectstack/core](../../core) - Core Interfaces and Types

package/dist/memory-driver.d.ts

@@ -1,5 +1,5 @@
 import { QueryInput } from '@objectstack/spec/data';
-import { DriverOptions } from '@objectstack/spec/system';
+import { DriverOptions } from '@objectstack/spec/data';
 import { DriverInterface } from '@objectstack/core';
 /**
  * Example: In-Memory Driver
@@ -11,6 +11,7 @@ export declare class InMemoryDriver implements DriverInterface {
     name: string;
     version: string;
     private config;
+    private logger;
     constructor(config?: any);
     install(ctx: any): void;
     supports: {

package/dist/memory-driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-driver.d.ts","sourceRoot":"","sources":["../src/memory-driver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,eAAe;IACpD,IAAI,SAAsB;IAC1B,OAAO,SAAW;IAClB,OAAO,CAAC,MAAM,CAAM;gBAER,MAAM,CAAC,EAAE,GAAG;IAKxB,OAAO,CAAC,GAAG,EAAE,GAAG;IAMhB,QAAQ;;;;;;;;;;;;;;MAmBN;IAEF;;OAEG;IACH,OAAO,CAAC,EAAE,CAA6B;IAMjC,OAAO;IAIP,UAAU;IAKV,WAAW;IAQX,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE;IASpC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAc9D,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAOtE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAKlE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;IAezE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa;IAkB9F,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAiBlG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;IAUnE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAQjE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;IAIpF,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAIjH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAQ5E,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,aAAa;IAO/D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;IAMjD,gBAAgB;IAIhB,MAAM;IACN,QAAQ;IAMd,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,UAAU;CAGnB"}
+{"version":3,"file":"memory-driver.d.ts","sourceRoot":"","sources":["../src/memory-driver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAwB,MAAM,mBAAmB,CAAC;AAE1E;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,eAAe;IACpD,IAAI,SAAsB;IAC1B,OAAO,SAAW;IAClB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,CAAC,EAAE,GAAG;IAOxB,OAAO,CAAC,GAAG,EAAE,GAAG;IAUhB,QAAQ;;;;;;;;;;;;;;MAmBN;IAEF;;OAEG;IACH,OAAO,CAAC,EAAE,CAA6B;IAMjC,OAAO;IAIP,UAAU;IAWV,WAAW;IAYX,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE;IASpC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAiB9D,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAStE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAUlE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;IAkBzE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa;IAsB9F,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAqBlG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;IAgBnE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAUjE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;IAOpF,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAOjH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAU5E,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,aAAa;IAO/D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;IAQjD,gBAAgB;IAIhB,MAAM;IACN,QAAQ;IAMd,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,UAAU;CAGnB"}

package/dist/memory-driver.js

@@ -1,3 +1,4 @@
+import { createLogger } from '@objectstack/core';
 /**
  * Example: In-Memory Driver
  *
@@ -31,37 +32,54 @@ export class InMemoryDriver {
          */
         this.db = {};
         this.config = config || {};
+        this.logger = config?.logger || createLogger({ level: 'info', format: 'pretty' });
+        this.logger.debug('InMemory driver instance created', { config: this.config });
     }
     // Duck-typed RuntimePlugin hook
     install(ctx) {
+        this.logger.debug('Installing InMemory driver via plugin hook');
         if (ctx.engine && ctx.engine.ql && typeof ctx.engine.ql.registerDriver === 'function') {
             ctx.engine.ql.registerDriver(this);
+            this.logger.info('InMemory driver registered with ObjectQL engine');
+        }
+        else {
+            this.logger.warn('Could not register driver - ObjectQL engine not found in context');
         }
     }
     // ===================================
     // Lifecycle
     // ===================================
     async connect() {
-        console.log('🔌 [InMemory] Database Connected (Virtual)');
+        this.logger.info('InMemory Database Connected (Virtual)');
     }
     async disconnect() {
+        const tableCount = Object.keys(this.db).length;
+        const recordCount = Object.values(this.db).reduce((sum, table) => sum + table.length, 0);
         this.db = {};
-        console.log('🔌 [InMemory] Database Disconnected & Cleared');
+        this.logger.info('InMemory Database Disconnected & Cleared', {
+            tableCount,
+            recordCount
+        });
     }
     async checkHealth() {
+        this.logger.debug('Health check performed', {
+            tableCount: Object.keys(this.db).length,
+            status: 'healthy'
+        });
         return true;
     }
     // ===================================
     // Execution
     // ===================================
     async execute(command, params) {
-        console.log('⚠️ [InMemory] Raw execution not supported, received:', command);
+        this.logger.warn('Raw execution not supported in InMemory driver', { command });
         return null;
     }
     // ===================================
     // CRUD
     // ===================================
     async find(object, query, options) {
+        this.logger.debug('Find operation', { object, query });
         const table = this.getTable(object);
         // 💡 Naive Implementation
         let results = [...table];
@@ -69,19 +87,25 @@ export class InMemoryDriver {
         if (query.limit) {
             results = results.slice(0, query.limit);
         }
+        this.logger.debug('Find completed', { object, resultCount: results.length });
         return results;
     }
     async *findStream(object, query, options) {
+        this.logger.debug('FindStream operation', { object });
         const results = await this.find(object, query, options);
         for (const record of results) {
             yield record;
         }
     }
     async findOne(object, query, options) {
+        this.logger.debug('FindOne operation', { object, query });
         const results = await this.find(object, { ...query, limit: 1 }, options);
-        return results[0] || null;
+        const result = results[0] || null;
+        this.logger.debug('FindOne completed', { object, found: !!result });
+        return result;
     }
     async create(object, data, options) {
+        this.logger.debug('Create operation', { object, hasData: !!data });
         const table = this.getTable(object);
         // COMPATIBILITY: Driver must return 'id' as string
         const newRecord = {
@@ -91,12 +115,15 @@ export class InMemoryDriver {
             updated_at: data.updated_at || new Date(),
         };
         table.push(newRecord);
+        this.logger.debug('Record created', { object, id: newRecord.id, tableSize: table.length });
         return newRecord;
     }
     async update(object, id, data, options) {
+        this.logger.debug('Update operation', { object, id });
         const table = this.getTable(object);
         const index = table.findIndex(r => r.id == id);
         if (index === -1) {
+            this.logger.warn('Record not found for update', { object, id });
             throw new Error(`Record with ID ${id} not found in ${object}`);
         }
         const updatedRecord = {
@@ -105,9 +132,11 @@ export class InMemoryDriver {
             updated_at: new Date()
         };
         table[index] = updatedRecord;
+        this.logger.debug('Record updated', { object, id });
         return updatedRecord;
     }
     async upsert(object, data, conflictKeys, options) {
+        this.logger.debug('Upsert operation', { object, conflictKeys });
         const table = this.getTable(object);
         let existingRecord = null;
         if (data.id) {
@@ -117,34 +146,50 @@ export class InMemoryDriver {
             existingRecord = table.find(r => conflictKeys.every(key => r[key] === data[key]));
         }
         if (existingRecord) {
+            this.logger.debug('Record exists, updating', { object, id: existingRecord.id });
             return this.update(object, existingRecord.id, data, options);
         }
         else {
+            this.logger.debug('Record does not exist, creating', { object });
             return this.create(object, data, options);
         }
     }
     async delete(object, id, options) {
+        this.logger.debug('Delete operation', { object, id });
         const table = this.getTable(object);
         const index = table.findIndex(r => r.id == id);
-        if (index === -1)
+        if (index === -1) {
+            this.logger.warn('Record not found for deletion', { object, id });
             return false;
+        }
         table.splice(index, 1);
+        this.logger.debug('Record deleted', { object, id, tableSize: table.length });
         return true;
     }
     async count(object, query, options) {
-        return this.getTable(object).length;
+        const count = this.getTable(object).length;
+        this.logger.debug('Count operation', { object, count });
+        return count;
     }
     // ===================================
     // Bulk Operations
     // ===================================
     async bulkCreate(object, dataArray, options) {
-        return Promise.all(dataArray.map(data => this.create(object, data, options)));
+        this.logger.debug('BulkCreate operation', { object, count: dataArray.length });
+        const results = await Promise.all(dataArray.map(data => this.create(object, data, options)));
+        this.logger.debug('BulkCreate completed', { object, count: results.length });
+        return results;
     }
     async bulkUpdate(object, updates, options) {
-        return Promise.all(updates.map(u => this.update(object, u.id, u.data, options)));
+        this.logger.debug('BulkUpdate operation', { object, count: updates.length });
+        const results = await Promise.all(updates.map(u => this.update(object, u.id, u.data, options)));
+        this.logger.debug('BulkUpdate completed', { object, count: results.length });
+        return results;
     }
     async bulkDelete(object, ids, options) {
+        this.logger.debug('BulkDelete operation', { object, count: ids.length });
         await Promise.all(ids.map(id => this.delete(object, id, options)));
+        this.logger.debug('BulkDelete completed', { object, count: ids.length });
     }
     // ===================================
     // Schema & Transactions
@@ -152,12 +197,14 @@ export class InMemoryDriver {
     async syncSchema(object, schema, options) {
         if (!this.db[object]) {
             this.db[object] = [];
-            console.log(`✨ [InMemory] Created table: ${object}`);
+            this.logger.info('Created in-memory table', { object });
         }
     }
     async dropTable(object, options) {
         if (this.db[object]) {
+            const recordCount = this.db[object].length;
             delete this.db[object];
+            this.logger.info('Dropped in-memory table', { object, recordCount });
         }
     }
     async beginTransaction() {

package/objectstack.config.ts

@@ -1,11 +1,17 @@
 import { ObjectStackManifest } from '@objectstack/spec/system';
 
+/**
+ * In-Memory Driver Plugin Manifest
+ * 
+ * Reference implementation of a storage driver that stores data in memory.
+ * Demonstrates the driver protocol implementation pattern.
+ */
 const MemoryDriverPlugin: ObjectStackManifest = {
   id: 'com.objectstack.driver.memory',
   name: 'In-Memory Driver',
   version: '1.0.0',
   type: 'driver',
-  description: 'A reference specificiation implementation of the DriverInterface using in-memory arrays.',
+  description: 'A reference specification implementation of the DriverInterface using in-memory arrays. Suitable for testing and development.',
   
   configuration: {
     title: 'Memory Driver Settings',
@@ -18,9 +24,234 @@ const MemoryDriverPlugin: ObjectStackManifest = {
     }
   },
 
+  // Plugin Capability Declaration
+  capabilities: {
+    // Protocols This Driver Implements
+    implements: [
+      {
+        protocol: {
+          id: 'com.objectstack.protocol.storage.v1',
+          label: 'Storage Protocol v1',
+          version: { major: 1, minor: 0, patch: 0 },
+          description: 'Standard data storage and retrieval operations',
+        },
+        conformance: 'partial',
+        implementedFeatures: [
+          'basic_crud',
+          'pagination',
+        ],
+        features: [
+          {
+            name: 'basic_crud',
+            enabled: true,
+            description: 'Create, read, update, delete operations',
+          },
+          {
+            name: 'pagination',
+            enabled: true,
+            description: 'Basic pagination via limit/offset',
+          },
+          {
+            name: 'query_filters',
+            enabled: false,
+            description: 'Advanced query filtering',
+          },
+          {
+            name: 'aggregations',
+            enabled: false,
+            description: 'Count, sum, avg operations',
+          },
+          {
+            name: 'sorting',
+            enabled: false,
+            description: 'Result set sorting',
+          },
+          {
+            name: 'transactions',
+            enabled: false,
+            description: 'ACID transaction support',
+          },
+          {
+            name: 'joins',
+            enabled: false,
+            description: 'Cross-object joins',
+          },
+        ],
+        certified: false,
+      },
+    ],
+
+    // Interfaces This Driver Provides
+    provides: [
+      {
+        id: 'com.objectstack.driver.memory.interface.driver',
+        name: 'DriverInterface',
+        description: 'Standard ObjectStack driver interface for data operations',
+        version: { major: 1, minor: 0, patch: 0 },
+        stability: 'stable',
+        methods: [
+          {
+            name: 'connect',
+            description: 'Initialize driver connection',
+            parameters: [],
+            returnType: 'Promise<void>',
+            async: true,
+          },
+          {
+            name: 'disconnect',
+            description: 'Close driver connection',
+            parameters: [],
+            returnType: 'Promise<void>',
+            async: true,
+          },
+          {
+            name: 'create',
+            description: 'Create a new record',
+            parameters: [
+              {
+                name: 'object',
+                type: 'string',
+                required: true,
+                description: 'Object name',
+              },
+              {
+                name: 'data',
+                type: 'Record<string, any>',
+                required: true,
+                description: 'Record data',
+              },
+            ],
+            returnType: 'Promise<any>',
+            async: true,
+          },
+          {
+            name: 'find',
+            description: 'Query records',
+            parameters: [
+              {
+                name: 'object',
+                type: 'string',
+                required: true,
+                description: 'Object name',
+              },
+              {
+                name: 'query',
+                type: 'QueryInput',
+                required: false,
+                description: 'Query parameters',
+              },
+            ],
+            returnType: 'Promise<any[]>',
+            async: true,
+          },
+          {
+            name: 'findOne',
+            description: 'Find a single record by ID',
+            parameters: [
+              {
+                name: 'object',
+                type: 'string',
+                required: true,
+                description: 'Object name',
+              },
+              {
+                name: 'id',
+                type: 'string',
+                required: true,
+                description: 'Record ID',
+              },
+            ],
+            returnType: 'Promise<any>',
+            async: true,
+          },
+          {
+            name: 'update',
+            description: 'Update a record',
+            parameters: [
+              {
+                name: 'object',
+                type: 'string',
+                required: true,
+                description: 'Object name',
+              },
+              {
+                name: 'id',
+                type: 'string',
+                required: true,
+                description: 'Record ID',
+              },
+              {
+                name: 'data',
+                type: 'Record<string, any>',
+                required: true,
+                description: 'Updated record data',
+              },
+            ],
+            returnType: 'Promise<any>',
+            async: true,
+          },
+          {
+            name: 'delete',
+            description: 'Delete a record',
+            parameters: [
+              {
+                name: 'object',
+                type: 'string',
+                required: true,
+                description: 'Object name',
+              },
+              {
+                name: 'id',
+                type: 'string',
+                required: true,
+                description: 'Record ID',
+              },
+            ],
+            returnType: 'Promise<boolean>',
+            async: true,
+          },
+          {
+            name: 'count',
+            description: 'Count records',
+            parameters: [
+              {
+                name: 'object',
+                type: 'string',
+                required: true,
+                description: 'Object name',
+              },
+              {
+                name: 'query',
+                type: 'QueryInput',
+                required: false,
+                description: 'Query parameters',
+              },
+            ],
+            returnType: 'Promise<number>',
+            async: true,
+          },
+        ],
+      },
+    ],
+
+    // No external plugin dependencies (this is a core driver)
+    requires: [],
+
+    // No extension points defined
+    extensionPoints: [],
+
+    // No extensions contributed
+    extensions: [],
+  },
+
   contributes: {
-     // If there was a 'drivers' definition here, we would use it.
-     // For now, we register via code (src/index.ts)
+    drivers: [
+      {
+        id: 'memory',
+        label: 'In-Memory Storage',
+        description: 'Stores data in memory (volatile, for testing/development)',
+      },
+    ],
   }
 };
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@objectstack/driver-memory",
-  "version": "0.6.1",
+  "version": "0.7.2",
   "description": "In-Memory Driver for ObjectStack (Reference Implementation)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@objectstack/core": "0.6.1",
-    "@objectstack/spec": "0.6.1"
+    "@objectstack/core": "0.7.2",
+    "@objectstack/spec": "0.7.2"
   },
   "devDependencies": {
     "typescript": "^5.0.0"

package/src/memory-driver.ts

@@ -1,6 +1,6 @@
 import { QueryAST, QueryInput } from '@objectstack/spec/data';
-import { DriverOptions } from '@objectstack/spec/system';
-import { DriverInterface } from '@objectstack/core';
+import { DriverOptions } from '@objectstack/spec/data';
+import { DriverInterface, Logger, createLogger } from '@objectstack/core';
 
 /**
  * Example: In-Memory Driver
@@ -12,15 +12,22 @@ export class InMemoryDriver implements DriverInterface {
   name = 'in-memory-driver';
   version = '0.0.1';
   private config: any;
+  private logger: Logger;
 
   constructor(config?: any) {
     this.config = config || {};
+    this.logger = config?.logger || createLogger({ level: 'info', format: 'pretty' });
+    this.logger.debug('InMemory driver instance created', { config: this.config });
   }
 
   // Duck-typed RuntimePlugin hook
   install(ctx: any) {
+    this.logger.debug('Installing InMemory driver via plugin hook');
     if (ctx.engine && ctx.engine.ql && typeof ctx.engine.ql.registerDriver === 'function') {
         ctx.engine.ql.registerDriver(this);
+        this.logger.info('InMemory driver registered with ObjectQL engine');
+    } else {
+        this.logger.warn('Could not register driver - ObjectQL engine not found in context');
     }
   }
   
@@ -55,15 +62,25 @@ export class InMemoryDriver implements DriverInterface {
   // ===================================
 
   async connect() {
-    console.log('🔌 [InMemory] Database Connected (Virtual)');
+    this.logger.info('InMemory Database Connected (Virtual)');
   }
 
   async disconnect() {
+    const tableCount = Object.keys(this.db).length;
+    const recordCount = Object.values(this.db).reduce((sum, table) => sum + table.length, 0);
+    
     this.db = {};
-    console.log('🔌 [InMemory] Database Disconnected & Cleared');
+    this.logger.info('InMemory Database Disconnected & Cleared', { 
+      tableCount, 
+      recordCount 
+    });
   }
 
   async checkHealth() {
+    this.logger.debug('Health check performed', { 
+      tableCount: Object.keys(this.db).length,
+      status: 'healthy' 
+    });
     return true; 
   }
 
@@ -72,7 +89,7 @@ export class InMemoryDriver implements DriverInterface {
   // ===================================
 
   async execute(command: any, params?: any[]) {
-    console.log('⚠️ [InMemory] Raw execution not supported, received:', command);
+    this.logger.warn('Raw execution not supported in InMemory driver', { command });
     return null;
   }
 
@@ -81,6 +98,8 @@ export class InMemoryDriver implements DriverInterface {
   // ===================================
 
   async find(object: string, query: QueryInput, options?: DriverOptions) {
+    this.logger.debug('Find operation', { object, query });
+    
     const table = this.getTable(object);
     
     // 💡 Naive Implementation
@@ -91,10 +110,13 @@ export class InMemoryDriver implements DriverInterface {
       results = results.slice(0, query.limit);
     }
 
+    this.logger.debug('Find completed', { object, resultCount: results.length });
     return results;
   }
 
   async *findStream(object: string, query: QueryInput, options?: DriverOptions) {
+    this.logger.debug('FindStream operation', { object });
+    
     const results = await this.find(object, query, options);
     for (const record of results) {
       yield record;
@@ -102,11 +124,18 @@ export class InMemoryDriver implements DriverInterface {
   }
 
   async findOne(object: string, query: QueryInput, options?: DriverOptions) {
+    this.logger.debug('FindOne operation', { object, query });
+    
     const results = await this.find(object, { ...query, limit: 1 }, options);
-    return results[0] || null;
+    const result = results[0] || null;
+    
+    this.logger.debug('FindOne completed', { object, found: !!result });
+    return result;
   }
 
   async create(object: string, data: Record<string, any>, options?: DriverOptions) {
+    this.logger.debug('Create operation', { object, hasData: !!data });
+    
     const table = this.getTable(object);
     
     // COMPATIBILITY: Driver must return 'id' as string
@@ -118,14 +147,18 @@ export class InMemoryDriver implements DriverInterface {
     };
 
     table.push(newRecord);
+    this.logger.debug('Record created', { object, id: newRecord.id, tableSize: table.length });
     return newRecord;
   }
 
   async update(object: string, id: string | number, data: Record<string, any>, options?: DriverOptions) {
+    this.logger.debug('Update operation', { object, id });
+    
     const table = this.getTable(object);
     const index = table.findIndex(r => r.id == id);
     
     if (index === -1) {
+      this.logger.warn('Record not found for update', { object, id });
       throw new Error(`Record with ID ${id} not found in ${object}`);
     }
 
@@ -136,10 +169,13 @@ export class InMemoryDriver implements DriverInterface {
     };
     
     table[index] = updatedRecord;
+    this.logger.debug('Record updated', { object, id });
     return updatedRecord;
   }
 
   async upsert(object: string, data: Record<string, any>, conflictKeys?: string[], options?: DriverOptions) {
+    this.logger.debug('Upsert operation', { object, conflictKeys });
+    
     const table = this.getTable(object);
     let existingRecord: any = null;
 
@@ -150,24 +186,34 @@ export class InMemoryDriver implements DriverInterface {
     }
 
     if (existingRecord) {
+        this.logger.debug('Record exists, updating', { object, id: existingRecord.id });
         return this.update(object, existingRecord.id, data, options);
     } else {
+        this.logger.debug('Record does not exist, creating', { object });
         return this.create(object, data, options);
     }
   }
 
   async delete(object: string, id: string | number, options?: DriverOptions) {
+    this.logger.debug('Delete operation', { object, id });
+    
     const table = this.getTable(object);
     const index = table.findIndex(r => r.id == id);
     
-    if (index === -1) return false;
+    if (index === -1) {
+      this.logger.warn('Record not found for deletion', { object, id });
+      return false;
+    }
 
     table.splice(index, 1);
+    this.logger.debug('Record deleted', { object, id, tableSize: table.length });
     return true;
   }
 
   async count(object: string, query?: QueryInput, options?: DriverOptions) {
-    return this.getTable(object).length;
+    const count = this.getTable(object).length;
+    this.logger.debug('Count operation', { object, count });
+    return count;
   }
 
   // ===================================
@@ -175,15 +221,23 @@ export class InMemoryDriver implements DriverInterface {
   // ===================================
 
   async bulkCreate(object: string, dataArray: Record<string, any>[], options?: DriverOptions) {
-    return Promise.all(dataArray.map(data => this.create(object, data, options)));
+    this.logger.debug('BulkCreate operation', { object, count: dataArray.length });
+    const results = await Promise.all(dataArray.map(data => this.create(object, data, options)));
+    this.logger.debug('BulkCreate completed', { object, count: results.length });
+    return results;
   }
 
   async bulkUpdate(object: string, updates: { id: string | number, data: Record<string, any> }[], options?: DriverOptions) {
-    return Promise.all(updates.map(u => this.update(object, u.id, u.data, options)));
+    this.logger.debug('BulkUpdate operation', { object, count: updates.length });
+    const results = await Promise.all(updates.map(u => this.update(object, u.id, u.data, options)));
+    this.logger.debug('BulkUpdate completed', { object, count: results.length });
+    return results;
   }
 
   async bulkDelete(object: string, ids: (string | number)[], options?: DriverOptions) {
+    this.logger.debug('BulkDelete operation', { object, count: ids.length });
     await Promise.all(ids.map(id => this.delete(object, id, options)));
+    this.logger.debug('BulkDelete completed', { object, count: ids.length });
   }
 
   // ===================================
@@ -193,13 +247,15 @@ export class InMemoryDriver implements DriverInterface {
   async syncSchema(object: string, schema: any, options?: DriverOptions) {
     if (!this.db[object]) {
       this.db[object] = [];
-      console.log(`✨ [InMemory] Created table: ${object}`);
+      this.logger.info('Created in-memory table', { object });
     }
   }
 
   async dropTable(object: string, options?: DriverOptions) {
     if (this.db[object]) {
+      const recordCount = this.db[object].length;
       delete this.db[object];
+      this.logger.info('Dropped in-memory table', { object, recordCount });
     }
   }