@objectql/core 1.3.1 → 1.5.0

package/src/loader.ts

@@ -101,6 +101,51 @@ export class ObjectLoader {
                 }
             }
         });
+
+        // Generic YAML Metadata Loaders
+        const metaTypes = ['view', 'form', 'menu', 'permission', 'report', 'workflow', 'validation', 'data'];
+        
+        for (const type of metaTypes) {
+            this.use({
+                name: type,
+                glob: [`**/*.${type}.yml`, `**/*.${type}.yaml`],
+                handler: (ctx) => {
+                    try {
+                        const doc = yaml.load(ctx.content) as any;
+                        if (!doc) return;
+
+                        // Use 'name' from doc, or filename base (without extension)
+                        let id = doc.name;
+                        if (!id && type !== 'data') {
+                            const basename = path.basename(ctx.file); 
+                            // e.g. "my-view.view.yml" -> "my-view"
+                            // Regex: remove .type.yml or .type.yaml
+                            const re = new RegExp(`\\.${type}\\.(yml|yaml)$`);
+                            id = basename.replace(re, '');
+                        }
+
+                        // Data entries might not need a name, but for registry we need an ID.
+                        // For data, we can use filename if not present.
+                         if (!id && type === 'data') {
+                            id = path.basename(ctx.file);
+                         }
+
+                        // Ensure name is in the doc for consistency
+                        if (!doc.name) doc.name = id;
+
+                        ctx.registry.register(type, {
+                            type: type,
+                            id: id,
+                            path: ctx.file,
+                            package: ctx.packageName,
+                            content: doc
+                        });
+                    } catch (e) {
+                         console.error(`Error loading ${type} from ${ctx.file}:`, e);
+                    }
+                }
+            })
+        }
     }
 
     use(plugin: LoaderPlugin) {
@@ -127,9 +172,39 @@ export class ObjectLoader {
     }
 
     private runPlugin(plugin: LoaderPlugin, dir: string, packageName?: string) {
+        // Enforce path conventions: 
+        // 1. Never scan node_modules (unless explicitly loaded via loadPackage which sets cwd inside it)
+        // 2. Ignore build artifacts (dist, build, out) to avoid double-loading metadata if both src and dist exist.
+        //    Note: If you want to load from 'dist', you must explicitly point the loader to it (e.g. loader.load('./dist')).
+        //    In that case, the patterns won't match relative to the CWD.
+        // Path conventions:
+        // 1. Always ignore node_modules and .git
+        const ignore = [
+            '**/node_modules/**', 
+            '**/.git/**'
+        ];
+
+        // 2. Intelligent handling of build artifacts (dist/build)
+        // If 'src' exists in the scan directory, we assume it's a Development Environment.
+        // In Dev, we ignore 'dist' to avoid duplicate loading (ts in src vs js in dist).
+        // In Production (no src), we must NOT ignore 'dist', otherwise we can't load compiled hooks/actions.
+        const srcPath = path.join(dir, 'src');
+        const hasSrc = fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory();
+
+        if (hasSrc) {
+            ignore.push('**/dist/**', '**/build/**', '**/out/**');
+        }
+
+        // 3. User instruction: "src 不行的" (src is not viable for metadata in production)
+        // Metadata (.yml) should ideally be placed in 'objects/' or root, not 'src/', 
+        // to simplify packaging (so you don't need to copy assets from src to dist).
+        // However, we do not strictly block 'src' scanning here to avoid breaking dev workflow.
+        // The exclusion of 'dist' in dev mode (above) handles the code duality.
+
         const files = glob.sync(plugin.glob, {
             cwd: dir,
-            absolute: true
+            absolute: true,
+            ignore
         });
 
         for (const file of files) {
@@ -166,6 +241,38 @@ function registerObject(registry: MetadataRegistry, obj: any, file: string, pack
             }
         }
     }
+
+    // Check for existing object to Merge
+    const existing = registry.getEntry('object', obj.name);
+    if (existing) {
+        const base = existing.content;
+        
+        // Merge Fields: New fields overwrite old ones
+        if (obj.fields) {
+            base.fields = { ...base.fields, ...obj.fields };
+        }
+        
+        // Merge Actions
+        if (obj.actions) {
+            base.actions = { ...base.actions, ...obj.actions };
+        }
+
+        // Merge Indexes
+        if (obj.indexes) {
+            base.indexes = { ...base.indexes, ...obj.indexes };
+        }
+        
+        // Override Top-level Properties if provided
+        if (obj.label) base.label = obj.label;
+        if (obj.icon) base.icon = obj.icon;
+        if (obj.description) base.description = obj.description;
+        if (obj.datasource) base.datasource = obj.datasource;
+        
+        // Update the content reference
+        existing.content = base;
+        return;
+    }
+
     registry.register('object', {
         type: 'object',
         id: obj.name,

package/src/repository.ts

@@ -39,12 +39,26 @@ export class ObjectRepository {
         };
     }
 
+    private getUserFromContext() {
+        if (!this.context.userId) {
+            return undefined;
+        }
+        // Construct user object from context, including relevant properties
+        return {
+            id: this.context.userId,
+            spaceId: this.context.spaceId,
+            roles: this.context.roles,
+            isSystem: this.context.isSystem
+        };
+    }
+
     async find(query: UnifiedQuery = {}): Promise<any[]> {
         const hookCtx: RetrievalHookContext = {
             ...this.context,
             objectName: this.objectName,
             operation: 'find',
             api: this.getHookAPI(),
+            user: this.getUserFromContext(),
             state: {},
             query
         };
@@ -65,7 +79,10 @@ export class ObjectRepository {
                 ...this.context,
                 objectName: this.objectName,
                 operation: 'find',
-                api: this.getHookAPI(),                state: {},                query: { _id: idOrQuery }
+                api: this.getHookAPI(),
+                user: this.getUserFromContext(),
+                state: {},
+                query: { _id: idOrQuery }
             };
             await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
             
@@ -86,6 +103,7 @@ export class ObjectRepository {
             objectName: this.objectName,
             operation: 'count',
             api: this.getHookAPI(),
+            user: this.getUserFromContext(),
             state: {},
             query: filters
         };
@@ -105,6 +123,7 @@ export class ObjectRepository {
             operation: 'create',
             state: {},
             api: this.getHookAPI(),
+            user: this.getUserFromContext(),
             data: doc
         };
         await this.app.triggerHook('beforeCreate', this.objectName, hookCtx);
@@ -122,14 +141,17 @@ export class ObjectRepository {
     }
 
     async update(id: string | number, doc: any, options?: any): Promise<any> {
+        const previousData = await this.findOne(id);
         const hookCtx: UpdateHookContext = {
             ...this.context,
             objectName: this.objectName,
             operation: 'update',
             state: {},
             api: this.getHookAPI(),
+            user: this.getUserFromContext(),
             id,
             data: doc,
+            previousData,
             isModified: (field) => hookCtx.data ? Object.prototype.hasOwnProperty.call(hookCtx.data, field) : false
         };
         await this.app.triggerHook('beforeUpdate', this.objectName, hookCtx);
@@ -142,13 +164,16 @@ export class ObjectRepository {
     }
 
     async delete(id: string | number): Promise<any> {
+        const previousData = await this.findOne(id);
         const hookCtx: MutationHookContext = {
             ...this.context,
             objectName: this.objectName,
             operation: 'delete',
             state: {},
             api: this.getHookAPI(),
-            id
+            user: this.getUserFromContext(),
+            id,
+            previousData
         };
         await this.app.triggerHook('beforeDelete', this.objectName, hookCtx);
 
@@ -221,7 +246,8 @@ export class ObjectRepository {
             actionName,
             id,
             input: params,
-            api
+            api,
+            user: this.getUserFromContext()
         };
         return await this.app.executeAction(this.objectName, actionName, ctx);
     }