@objectql/create 1.0.0

package/templates/enterprise/__tests__/metadata-api.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Metadata API Tests for Enterprise Starter
+ * 
+ * Tests metadata API operations for enterprise objects
+ */
+
+import { ObjectQL } from '@objectql/core';
+import { SqlDriver } from '@objectql/driver-sql';
+import { ObjectLoader } from '@objectql/platform-node';
+import * as path from 'path';
+
+describe('Enterprise Metadata API', () => {
+    let app: ObjectQL;
+
+    beforeAll(async () => {
+        // Initialize ObjectQL
+        app = new ObjectQL({
+            datasources: {
+                default: new SqlDriver({
+                    client: 'sqlite3',
+                    connection: {
+                        filename: ':memory:'
+                    },
+                    useNullAsDefault: true
+                })
+            }
+        });
+
+        // Load metadata
+        const srcDir = path.resolve(__dirname, '../src');
+        const loader = new ObjectLoader(app.metadata);
+        loader.load(srcDir);
+
+        await app.init();
+    });
+
+    afterAll(async () => {
+        if (app && (app as any).datasources?.default) {
+            const driver = (app as any).datasources.default;
+            if (driver.knex) {
+                await driver.knex.destroy();
+            }
+        }
+    });
+
+    describe('Object Metadata Retrieval', () => {
+        it('should get all object configurations', () => {
+            const configs = app.getConfigs();
+            
+            expect(configs).toBeDefined();
+            expect(Object.keys(configs).length).toBeGreaterThanOrEqual(15);
+        });
+
+        it('should get specific core object metadata', () => {
+            const userConfig = app.getObject('user');
+            
+            expect(userConfig).toBeDefined();
+            expect(userConfig.name).toBe('user');
+            expect(userConfig.fields).toBeDefined();
+        });
+
+        it('should get specific CRM object metadata', () => {
+            const accountConfig = app.getObject('crm_account');
+            
+            expect(accountConfig).toBeDefined();
+            expect(accountConfig.name).toBe('crm_account');
+            expect(accountConfig.fields).toBeDefined();
+        });
+
+        it('should get specific HR object metadata', () => {
+            const employeeConfig = app.getObject('hr_employee');
+            
+            expect(employeeConfig).toBeDefined();
+            expect(employeeConfig.name).toBe('hr_employee');
+            expect(employeeConfig.fields).toBeDefined();
+        });
+
+        it('should get specific Project object metadata', () => {
+            const projectConfig = app.getObject('project_project');
+            
+            expect(projectConfig).toBeDefined();
+            expect(projectConfig.name).toBe('project_project');
+            expect(projectConfig.fields).toBeDefined();
+        });
+
+        it('should get specific Finance object metadata', () => {
+            const invoiceConfig = app.getObject('finance_invoice');
+            
+            expect(invoiceConfig).toBeDefined();
+            expect(invoiceConfig.name).toBe('finance_invoice');
+            expect(invoiceConfig.fields).toBeDefined();
+        });
+    });
+
+    describe('Metadata Registry Operations', () => {
+        it('should list all objects via metadata.list', () => {
+            const objects = app.metadata.list('object');
+            
+            expect(objects).toBeDefined();
+            expect(Array.isArray(objects)).toBe(true);
+            expect(objects.length).toBeGreaterThanOrEqual(15);
+        });
+
+        it('should get object via metadata.get', () => {
+            const userMeta = app.metadata.get('object', 'user');
+            
+            expect(userMeta).toBeDefined();
+            expect(userMeta.name).toBe('user');
+        });
+
+        it('should get CRM object via metadata.get', () => {
+            const accountMeta = app.metadata.get('object', 'crm_account');
+            
+            expect(accountMeta).toBeDefined();
+            expect(accountMeta.name).toBe('crm_account');
+        });
+
+        it('should list extensions if present', () => {
+            const extensions = app.metadata.list('extension');
+            
+            expect(extensions).toBeDefined();
+            expect(Array.isArray(extensions)).toBe(true);
+        });
+
+        it('should list apps if present', () => {
+            const apps = app.metadata.list('app');
+            
+            expect(apps).toBeDefined();
+            expect(Array.isArray(apps)).toBe(true);
+        });
+
+        it('should list menus if present', () => {
+            const menus = app.metadata.list('menu');
+            
+            expect(menus).toBeDefined();
+            expect(Array.isArray(menus)).toBe(true);
+        });
+    });
+
+    describe('Field Metadata', () => {
+        it('should retrieve User field metadata', () => {
+            const userConfig = app.getObject('user');
+            
+            expect(userConfig.fields).toBeDefined();
+            expect(userConfig.fields.name).toBeDefined();
+            expect(userConfig.fields.email).toBeDefined();
+        });
+
+        it('should retrieve CRM Account field metadata', () => {
+            const accountConfig = app.getObject('crm_account');
+            
+            expect(accountConfig.fields).toBeDefined();
+            expect(accountConfig.fields.name).toBeDefined();
+        });
+
+        it('should retrieve HR Employee field metadata', () => {
+            const employeeConfig = app.getObject('hr_employee');
+            
+            expect(employeeConfig.fields).toBeDefined();
+            expect(employeeConfig.fields.first_name).toBeDefined();
+            expect(employeeConfig.fields.last_name).toBeDefined();
+        });
+
+        it('should retrieve Project field metadata', () => {
+            const projectConfig = app.getObject('project_project');
+            
+            expect(projectConfig.fields).toBeDefined();
+            expect(projectConfig.fields.name).toBeDefined();
+        });
+
+        it('should retrieve Finance Invoice field metadata', () => {
+            const invoiceConfig = app.getObject('finance_invoice');
+            
+            expect(invoiceConfig.fields).toBeDefined();
+            expect(invoiceConfig.fields.invoice_number).toBeDefined();
+        });
+    });
+
+    describe('Module Organization Metadata', () => {
+        it('should identify objects by module prefix', () => {
+            const configs = app.getConfigs();
+            const objectNames = Object.keys(configs);
+            console.log('Object Names:', objectNames); // Debugging
+            
+            const crmObjects = objectNames.filter(name => name.startsWith('crm_'));
+            const hrObjects = objectNames.filter(name => name.startsWith('hr_'));
+            const projectObjects = objectNames.filter(name => name.startsWith('project_'));
+            const financeObjects = objectNames.filter(name => name.startsWith('finance_'));
+            
+            expect(crmObjects.length).toBeGreaterThanOrEqual(3);
+            expect(hrObjects.length).toBeGreaterThanOrEqual(3);
+            expect(projectObjects.length).toBeGreaterThanOrEqual(3);
+            expect(financeObjects.length).toBeGreaterThanOrEqual(2);
+        });
+
+        it('should have consistent naming convention', () => {
+            const configs = app.getConfigs();
+            const objectNames = Object.keys(configs);
+            
+            // Check that module objects follow Module_Name pattern
+            const moduleObjects = objectNames.filter(name => 
+                name.startsWith('CRM_') || 
+                name.startsWith('HR_') || 
+                name.startsWith('Project_') || 
+                name.startsWith('Finance_')
+            );
+            
+            moduleObjects.forEach(name => {
+                expect(name).toMatch(/^[A-Z][a-zA-Z]+_[A-Z]/);
+            });
+        });
+    });
+
+    describe('Metadata Completeness', () => {
+        it('should have labels for all objects', () => {
+            const configs = app.getConfigs();
+            
+            Object.values(configs).forEach((config: any) => {
+                expect(config.label || config.name).toBeDefined();
+            });
+        });
+
+        it('should have fields for all objects', () => {
+            const configs = app.getConfigs();
+            
+            Object.values(configs).forEach((config: any) => {
+                expect(config.fields).toBeDefined();
+                expect(Object.keys(config.fields).length).toBeGreaterThan(0);
+            });
+        });
+
+        it('should have valid field types', () => {
+            const configs = app.getConfigs();
+            const validTypes = ['string', 'text', 'textarea', 'number', 'boolean', 'date', 'datetime', 
+                               'select', 'lookup', 'master_detail', 'url', 'email', 'phone',
+                               'currency', 'formula', 'html', 'markdown', 'password', 'file', 
+                               'image', 'avatar', 'location', 'percent'];
+            
+            Object.values(configs).forEach((config: any) => {
+                Object.values(config.fields).forEach((field: any) => {
+                    if (field.type) {
+                        expect(validTypes).toContain(field.type);
+                    }
+                });
+            });
+        });
+    });
+
+    describe('Metadata Consistency', () => {
+        it('should return same metadata via different access methods', () => {
+            const viaGetObject = app.getObject('user');
+            const viaMetadataGet = app.metadata.get('object', 'user');
+            
+            expect(viaGetObject.name).toBe(viaMetadataGet.name);
+            expect(viaGetObject.label).toBe(viaMetadataGet.label);
+        });
+
+        it('should have consistent object count', () => {
+            const viaGetConfigs = Object.keys(app.getConfigs()).length;
+            const viaMetadataList = app.metadata.list('object').length;
+            
+            expect(viaGetConfigs).toBe(viaMetadataList);
+        });
+    });
+
+    describe('Extension Metadata', () => {
+        it('should load user extension metadata if present', () => {
+            const extensions = app.metadata.list('extension');
+            
+            if (extensions && extensions.length > 0) {
+                const userExtension = extensions.find((ext: any) => 
+                    ext.id && ext.id.includes('user')
+                );
+                
+                if (userExtension) {
+                    expect(userExtension).toBeDefined();
+                }
+            }
+        });
+    });
+
+    describe('Application Metadata', () => {
+        it('should load ERP app metadata if present', () => {
+            const apps = app.metadata.list('app');
+            
+            if (apps && apps.length > 0) {
+                const erpApp = apps.find((app: any) => 
+                    app.id && app.id.toLowerCase().includes('erp')
+                );
+                
+                if (erpApp) {
+                    expect(erpApp).toBeDefined();
+                }
+            }
+        });
+    });
+
+    describe('Menu Metadata', () => {
+        it('should load menu metadata if present', () => {
+            const menus = app.metadata.list('menu');
+            
+            if (menus && menus.length > 0) {
+                expect(menus[0]).toBeDefined();
+            }
+        });
+    });
+});

package/templates/enterprise/__tests__/metadata-loading.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Metadata Loading Tests for Enterprise Starter
+ * 
+ * Tests that the enterprise-scale metadata organization is correctly loaded
+ */
+
+import { ObjectQL } from '@objectql/core';
+import { SqlDriver } from '@objectql/driver-sql';
+import { ObjectLoader } from '@objectql/platform-node';
+import * as path from 'path';
+
+describe('Enterprise Metadata Loading', () => {
+    let app: ObjectQL;
+
+    beforeAll(async () => {
+        // Initialize ObjectQL
+        app = new ObjectQL({
+            datasources: {
+                default: new SqlDriver({
+                    client: 'sqlite3',
+                    connection: {
+                        filename: ':memory:'
+                    },
+                    useNullAsDefault: true
+                })
+            }
+        });
+
+        // Load metadata from src directory (modular structure)
+        const srcDir = path.resolve(__dirname, '../src');
+        const loader = new ObjectLoader(app.metadata);
+        loader.load(srcDir);
+
+        await app.init();
+    });
+
+    afterAll(async () => {
+        if (app && (app as any).datasources?.default) {
+            const driver = (app as any).datasources.default;
+            if (driver.knex) {
+                await driver.knex.destroy();
+            }
+        }
+    });
+
+    describe('Core Objects', () => {
+        it('should load User core object', () => {
+            const userConfig = app.getObject('user');
+            
+            expect(userConfig).toBeDefined();
+            expect(userConfig.name).toBe('user');
+        });
+
+        it('should load Organization core object', () => {
+            const orgConfig = app.getObject('organization');
+            
+            expect(orgConfig).toBeDefined();
+            expect(orgConfig.name).toBe('organization');
+        });
+
+        it('should load Attachment core object', () => {
+            const attachmentConfig = app.getObject('attachment');
+            
+            expect(attachmentConfig).toBeDefined();
+            expect(attachmentConfig.name).toBe('attachment');
+        });
+    });
+
+    describe('CRM Module Objects', () => {
+        it('should load CRM Account object', () => {
+            const accountConfig = app.getObject('crm_account');
+            
+            expect(accountConfig).toBeDefined();
+            expect(accountConfig.name).toBe('crm_account');
+        });
+
+        it('should load CRM Contact object', () => {
+            const contactConfig = app.getObject('crm_contact');
+            
+            expect(contactConfig).toBeDefined();
+            expect(contactConfig.name).toBe('crm_contact');
+        });
+
+        it('should load CRM Lead object', () => {
+            const leadConfig = app.getObject('crm_lead');
+            
+            expect(leadConfig).toBeDefined();
+            expect(leadConfig.name).toBe('crm_lead');
+        });
+
+        it('should load CRM Opportunity object', () => {
+            const opportunityConfig = app.getObject('crm_opportunity');
+            
+            expect(opportunityConfig).toBeDefined();
+            expect(opportunityConfig.name).toBe('crm_opportunity');
+        });
+    });
+
+    describe('HR Module Objects', () => {
+        it('should load HR Employee object', () => {
+            const employeeConfig = app.getObject('hr_employee');
+            
+            expect(employeeConfig).toBeDefined();
+            expect(employeeConfig.name).toBe('hr_employee');
+        });
+
+        it('should load HR Department object', () => {
+            const deptConfig = app.getObject('hr_department');
+            
+            expect(deptConfig).toBeDefined();
+            expect(deptConfig.name).toBe('hr_department');
+        });
+
+        it('should load HR Position object', () => {
+            const posConfig = app.getObject('hr_position');
+            
+            expect(posConfig).toBeDefined();
+            expect(posConfig.name).toBe('hr_position');
+        });
+
+        it('should load HR Timesheet object', () => {
+            const timesheetConfig = app.getObject('hr_timesheet');
+            
+            expect(timesheetConfig).toBeDefined();
+            expect(timesheetConfig.name).toBe('hr_timesheet');
+        });
+    });
+
+    describe('Project Module Objects', () => {
+        it('should load Project Project object', () => {
+            const projectConfig = app.getObject('project_project');
+            
+            expect(projectConfig).toBeDefined();
+            expect(projectConfig.name).toBe('project_project');
+        });
+
+        it('should load Project Task object', () => {
+            const taskConfig = app.getObject('project_task');
+            
+            expect(taskConfig).toBeDefined();
+            expect(taskConfig.name).toBe('project_task');
+        });
+
+        it('should load Project Milestone object', () => {
+            const milestoneConfig = app.getObject('project_milestone');
+            
+            expect(milestoneConfig).toBeDefined();
+            expect(milestoneConfig.name).toBe('project_milestone');
+        });
+
+        it('should load Project Timesheet Entry object', () => {
+            const entryConfig = app.getObject('project_timesheet_entry');
+            
+            expect(entryConfig).toBeDefined();
+            expect(entryConfig.name).toBe('project_timesheet_entry');
+        });
+    });
+
+    describe('Finance Module Objects', () => {
+        it('should load Finance Invoice object', () => {
+            const invoiceConfig = app.getObject('finance_invoice');
+            
+            expect(invoiceConfig).toBeDefined();
+            expect(invoiceConfig.name).toBe('finance_invoice');
+        });
+
+        it('should load Finance Payment object', () => {
+            const paymentConfig = app.getObject('finance_payment');
+            
+            expect(paymentConfig).toBeDefined();
+            expect(paymentConfig.name).toBe('finance_payment');
+        });
+
+        it('should load Finance Expense object', () => {
+            const expenseConfig = app.getObject('finance_expense');
+            
+            expect(expenseConfig).toBeDefined();
+            expect(expenseConfig.name).toBe('finance_expense');
+        });
+    });
+
+    describe('Module-based Organization', () => {
+        it('should load objects from multiple modules', () => {
+            const configs = app.getConfigs();
+            const objectNames = Object.keys(configs);
+            
+            // Should have objects from different modules
+            const hasCRM = objectNames.some(name => name.startsWith('crm_'));
+            const hasHR = objectNames.some(name => name.startsWith('hr_'));
+            const hasProject = objectNames.some(name => name.startsWith('project_'));
+            const hasFinance = objectNames.some(name => name.startsWith('finance_'));
+            
+            expect(hasCRM).toBe(true);
+            expect(hasHR).toBe(true);
+            expect(hasProject).toBe(true);
+            expect(hasFinance).toBe(true);
+        });
+
+        it('should have significant number of objects loaded', () => {
+            const configs = app.getConfigs();
+            const objectCount = Object.keys(configs).length;
+            
+            // Enterprise starter should have at least 15 objects
+            expect(objectCount).toBeGreaterThanOrEqual(15);
+        });
+    });
+
+    describe('Extensions and Apps', () => {
+        it('should load User extension if present', () => {
+            const extensions = app.metadata.list('extension');
+            
+            if (extensions && extensions.length > 0) {
+                expect(extensions.length).toBeGreaterThanOrEqual(1);
+            }
+        });
+
+        it('should load ERP app metadata if present', () => {
+            const apps = app.metadata.list('app');
+            
+            if (apps && apps.length > 0) {
+                expect(apps.length).toBeGreaterThanOrEqual(1);
+            }
+        });
+
+        it('should load menu metadata if present', () => {
+            const menus = app.metadata.list('menu');
+            
+            if (menus && menus.length > 0) {
+                expect(menus.length).toBeGreaterThanOrEqual(1);
+            }
+        });
+    });
+
+    describe('Metadata Registry', () => {
+        it('should support listing all objects', () => {
+            const objects = app.metadata.list('object');
+            
+            expect(objects).toBeDefined();
+            expect(objects.length).toBeGreaterThanOrEqual(15);
+        });
+
+        it('should support getting specific objects', () => {
+            const userMeta = app.metadata.get('object', 'user');
+            const accountMeta = app.metadata.get('object', 'crm_account');
+            
+            expect(userMeta).toBeDefined();
+            expect(accountMeta).toBeDefined();
+        });
+    });
+});

package/templates/enterprise/jest.config.js

@@ -0,0 +1,22 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  moduleNameMapper: {
+    '^@objectql/core$': '<rootDir>/../../foundation/core/src',
+    '^@objectql/types$': '<rootDir>/../../foundation/types/src',
+    '^@objectql/platform-node$': '<rootDir>/../../foundation/platform-node/src',
+    '^@objectql/driver-sql$': '<rootDir>/../../drivers/sql/src',
+    '^@objectql/driver-mongo$': '<rootDir>/../../drivers/mongo/src',
+    '^@objectql/server$': '<rootDir>/../../runtime/server/src',
+  },
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      isolatedModules: true,
+    }],
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+  ],
+};

package/templates/enterprise/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@objectql/example-enterprise-erp",
+  "version": "1.8.4",
+  "description": "ObjectQL Enterprise Example - CRM & HR Demo",
+  "private": true,
+  "keywords": [
+    "objectql",
+    "module",
+    "enterprise",
+    "crm",
+    "hr",
+    "workflow",
+    "standard-library"
+  ],
+  "license": "MIT",
+  "author": "ObjectQL Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/objectql/objectql.git",
+    "directory": "examples/showcase/enterprise-erp"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "ts-node src/index.ts",
+    "codegen": "objectql generate -s src -o src/types",
+    "build": "npm run codegen && tsc && rsync -a --include '*/' --include '*.yml' --exclude '*' src/ dist/",
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "@objectql/core": "workspace:*",
+    "@objectql/types": "workspace:*",
+    "@objectql/driver-sql": "workspace:*",
+    "@objectql/platform-node": "workspace:*",
+    "sqlite3": "^5.1.7"
+  },
+  "devDependencies": {
+    "@objectql/core": "workspace:*",
+    "@objectql/types": "workspace:*",
+    "@objectql/cli": "workspace:*",
+    "@objectql/driver-sql": "workspace:*",
+    "@objectql/platform-node": "workspace:*",
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.3.0"
+  }
+}

package/templates/enterprise/src/apps/erp.app.yml

@@ -0,0 +1,4 @@
+name: erp
+label: Enterprise RPG
+description: Core ERP system
+icon: building

package/templates/enterprise/src/core/attachment.object.yml

@@ -0,0 +1,57 @@
+name: attachment
+label: Attachment
+description: File attachment for any object
+icon: attachment-line
+
+fields:
+  name:
+    type: text
+    required: true
+    label: File Name
+    index: true
+  
+  file_url:
+    type: file
+    required: true
+    label: File URL
+  
+  file_size:
+    type: number
+    label: File Size (bytes)
+  
+  file_type:
+    type: text
+    label: MIME Type
+    index: true
+  
+  related_to:
+    type: text
+    label: Related Object Name
+    index: true
+  
+  related_id:
+    type: text
+    label: Related Record ID
+    index: true
+  
+  uploaded_by:
+    type: lookup
+    reference_to: user
+    label: Uploaded By
+  
+  description:
+    type: textarea
+    label: Description
+  
+  tags:
+    type: text
+    label: Tags (comma-separated)
+
+indexes:
+  # For finding attachments of a specific record
+  related_composite_idx:
+    fields: [related_to, related_id]
+  
+  # For file type filtering
+  type_created_idx:
+    fields: [file_type, created_at]