@objectstack/objectql 1.0.4 → 1.0.5

package/dist/protocol.js

@@ -1,247 +0,0 @@
-// We import SchemaRegistry directly since this class lives in the same package
-import { SchemaRegistry } from './registry.js';
-/**
- * Simple hash function for ETag generation (browser-compatible)
- * Uses a basic hash algorithm instead of crypto.createHash
- */
-function simpleHash(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return Math.abs(hash).toString(16);
-}
-export class ObjectStackProtocolImplementation {
-    constructor(engine) {
-        this.engine = engine;
-    }
-    async getDiscovery(_request) {
-        return {
-            version: '1.0',
-            apiName: 'ObjectStack API',
-            capabilities: {
-                graphql: false,
-                search: false,
-                websockets: false,
-                files: true,
-                analytics: false,
-                hub: false
-            },
-            endpoints: {
-                data: '/api/data',
-                metadata: '/api/meta',
-                auth: '/api/auth'
-            }
-        };
-    }
-    async getMetaTypes(_request) {
-        return {
-            types: SchemaRegistry.getRegisteredTypes()
-        };
-    }
-    async getMetaItems(request) {
-        return {
-            type: request.type,
-            items: SchemaRegistry.listItems(request.type)
-        };
-    }
-    async getMetaItem(request) {
-        return {
-            type: request.type,
-            name: request.name,
-            item: SchemaRegistry.getItem(request.type, request.name)
-        };
-    }
-    async getUiView(request) {
-        const schema = SchemaRegistry.getObject(request.object);
-        if (!schema)
-            throw new Error(`Object ${request.object} not found`);
-        let view;
-        if (request.type === 'list') {
-            view = {
-                type: 'list',
-                object: request.object,
-                columns: Object.keys(schema.fields || {}).slice(0, 5).map(f => ({
-                    field: f,
-                    label: schema.fields[f].label || f
-                }))
-            };
-        }
-        else {
-            view = {
-                type: 'form',
-                object: request.object,
-                sections: [
-                    {
-                        label: 'General',
-                        fields: Object.keys(schema.fields || {}).map(f => ({
-                            field: f
-                        }))
-                    }
-                ]
-            };
-        }
-        return view;
-    }
-    async findData(request) {
-        // TODO: Normalize query from HTTP Query params (string values) to DataEngineQueryOptions (typed)
-        // For now, we assume query is partially compatible or simple enough.
-        // We should parse 'top', 'skip', 'limit' to numbers if they are strings.
-        const options = { ...request.query };
-        if (options.top)
-            options.top = Number(options.top);
-        if (options.skip)
-            options.skip = Number(options.skip);
-        if (options.limit)
-            options.limit = Number(options.limit);
-        // Handle OData style $filter if present, or flat filters
-        // This is a naive implementation, a real OData parser is needed for complex scenarios.
-        const records = await this.engine.find(request.object, options);
-        return {
-            object: request.object,
-            value: records, // OData compaibility
-            records, // Legacy
-            total: records.length,
-            hasMore: false
-        };
-    }
-    async getData(request) {
-        const result = await this.engine.findOne(request.object, {
-            filter: { _id: request.id }
-        });
-        if (result) {
-            return {
-                object: request.object,
-                id: request.id,
-                record: result
-            };
-        }
-        throw new Error(`Record ${request.id} not found in ${request.object}`);
-    }
-    async createData(request) {
-        const result = await this.engine.insert(request.object, request.data);
-        return {
-            object: request.object,
-            id: result._id || result.id,
-            record: result
-        };
-    }
-    async updateData(request) {
-        // Adapt: update(obj, id, data) -> update(obj, data, options)
-        const result = await this.engine.update(request.object, request.data, { filter: { _id: request.id } });
-        return {
-            object: request.object,
-            id: request.id,
-            record: result
-        };
-    }
-    async deleteData(request) {
-        // Adapt: delete(obj, id) -> delete(obj, options)
-        await this.engine.delete(request.object, { filter: { _id: request.id } });
-        return {
-            object: request.object,
-            id: request.id,
-            success: true
-        };
-    }
-    // ==========================================
-    // Metadata Caching
-    // ==========================================
-    async getMetaItemCached(request) {
-        try {
-            const item = SchemaRegistry.getItem(request.type, request.name);
-            if (!item) {
-                throw new Error(`Metadata item ${request.type}/${request.name} not found`);
-            }
-            // Calculate ETag (simple hash of the stringified metadata)
-            const content = JSON.stringify(item);
-            const hash = simpleHash(content);
-            const etag = { value: hash, weak: false };
-            // Check If-None-Match header
-            if (request.cacheRequest?.ifNoneMatch) {
-                const clientEtag = request.cacheRequest.ifNoneMatch.replace(/^"(.*)"$/, '$1').replace(/^W\/"(.*)"$/, '$1');
-                if (clientEtag === hash) {
-                    // Return 304 Not Modified
-                    return {
-                        notModified: true,
-                        etag,
-                    };
-                }
-            }
-            // Return full metadata with cache headers
-            return {
-                data: item,
-                etag,
-                lastModified: new Date().toISOString(),
-                cacheControl: {
-                    directives: ['public', 'max-age'],
-                    maxAge: 3600, // 1 hour
-                },
-                notModified: false,
-            };
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    // ==========================================
-    // Batch Operations
-    // ==========================================
-    async batchData(_request) {
-        // Map high-level batch request to DataEngine batch if available
-        // Or implement loop here.
-        // For now, let's just fail or implement basic loop to satisfying interface
-        // since full batch mapping requires careful type handling.
-        throw new Error('Batch operations not yet fully implemented in protocol adapter');
-    }
-    async createManyData(request) {
-        const records = await this.engine.insert(request.object, request.records);
-        return {
-            object: request.object,
-            records,
-            count: records.length
-        };
-    }
-    async updateManyData(_request) {
-        // TODO: Implement proper updateMany in DataEngine
-        throw new Error('updateManyData not implemented');
-    }
-    async analyticsQuery(_request) {
-        throw new Error('analyticsQuery not implemented');
-    }
-    async getAnalyticsMeta(_request) {
-        throw new Error('getAnalyticsMeta not implemented');
-    }
-    async triggerAutomation(_request) {
-        throw new Error('triggerAutomation not implemented');
-    }
-    async listSpaces(_request) {
-        throw new Error('listSpaces not implemented');
-    }
-    async createSpace(_request) {
-        throw new Error('createSpace not implemented');
-    }
-    async installPlugin(_request) {
-        throw new Error('installPlugin not implemented');
-    }
-    async deleteManyData(request) {
-        // This expects deleting by IDs.
-        return this.engine.delete(request.object, {
-            filter: { _id: { $in: request.ids } },
-            ...request.options
-        });
-    }
-    async saveMetaItem(request) {
-        if (!request.item) {
-            throw new Error('Item data is required');
-        }
-        // Default implementation saves to Memory Registry
-        SchemaRegistry.registerItem(request.type, request.item, 'name');
-        return {
-            success: true,
-            message: 'Saved to memory registry'
-        };
-    }
-}

package/dist/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}

package/dist/registry.js

@@ -1,119 +0,0 @@
-import { ObjectSchema } from '@objectstack/spec/data';
-import { ManifestSchema } from '@objectstack/spec/kernel';
-import { AppSchema } from '@objectstack/spec/ui';
-/**
- * Global Schema Registry
- * Unified storage for all metadata types (Objects, Apps, Flows, Layouts, etc.)
- */
-export class SchemaRegistry {
-    /**
-     * Universal Register Method
-     * @param type The category of metadata (e.g., 'object', 'app', 'plugin')
-     * @param item The metadata item itself
-     * @param keyField The property to use as the unique key (default: 'name')
-     */
-    static registerItem(type, item, keyField = 'name') {
-        if (!this.metadata.has(type)) {
-            this.metadata.set(type, new Map());
-        }
-        const collection = this.metadata.get(type);
-        const key = String(item[keyField]);
-        // Validation Hook
-        try {
-            this.validate(type, item);
-        }
-        catch (e) {
-            console.error(`[Registry] Validation failed for ${type} ${key}: ${e.message}`);
-            // For now, warn but don't crash, allowing partial/legacy loads
-            // throw e; 
-        }
-        if (collection.has(key)) {
-            console.warn(`[Registry] Overwriting ${type}: ${key}`);
-        }
-        collection.set(key, item);
-        console.log(`[Registry] Registered ${type}: ${key}`);
-    }
-    /**
-     * Validate Metadata against Spec Zod Schemas
-     */
-    static validate(type, item) {
-        if (type === 'object') {
-            return ObjectSchema.parse(item);
-        }
-        if (type === 'app') {
-            // AppSchema might rely on Zod, imported via UI protocol
-            return AppSchema.parse(item);
-        }
-        if (type === 'plugin') {
-            return ManifestSchema.parse(item);
-        }
-        // Add more validations as needed
-        return true;
-    }
-    /**
-     * Universal Unregister Method
-     */
-    static unregisterItem(type, name) {
-        const collection = this.metadata.get(type);
-        if (collection && collection.has(name)) {
-            collection.delete(name);
-            console.log(`[Registry] Unregistered ${type}: ${name}`);
-        }
-        else {
-            console.warn(`[Registry] Attempted to unregister non-existent ${type}: ${name}`);
-        }
-    }
-    /**
-     * Universal Get Method
-     */
-    static getItem(type, name) {
-        return this.metadata.get(type)?.get(name);
-    }
-    /**
-     * Universal List Method
-     */
-    static listItems(type) {
-        return Array.from(this.metadata.get(type)?.values() || []);
-    }
-    /**
-     * Get all registered metadata types (Kinds)
-     */
-    static getRegisteredTypes() {
-        return Array.from(this.metadata.keys());
-    }
-    // ==========================================
-    // Typed Helper Methods (Shortcuts)
-    // ==========================================
-    /**
-     * Object Helpers
-     */
-    static registerObject(schema) {
-        this.registerItem('object', schema, 'name');
-    }
-    static getObject(name) {
-        return this.getItem('object', name);
-    }
-    static getAllObjects() {
-        return this.listItems('object');
-    }
-    /**
-     * Plugin Helpers
-     */
-    static registerPlugin(manifest) {
-        this.registerItem('plugin', manifest, 'id');
-    }
-    static getAllPlugins() {
-        return this.listItems('plugin');
-    }
-    /**
-     * Kind (Metadata Type) Helpers
-     */
-    static registerKind(kind) {
-        this.registerItem('kind', kind, 'id');
-    }
-    static getAllKinds() {
-        return this.listItems('kind');
-    }
-}
-// Nested Map: Type -> Name/ID -> MetadataItem
-SchemaRegistry.metadata = new Map();