doix-db 1.0.10 → 1.0.11

package/index.js

@@ -10,11 +10,12 @@ module.exports = {
 	DbRelation:     require ('./lib/model/DbRelation.js'),	
 	DbTable:        require ('./lib/model/DbTable.js'),
 	DbView:         require ('./lib/model/DbView.js'),
-	DbObjectMap:    require ('./lib/model/DbObjectMap.js'),
+	DbSchemaSource: require ('./lib/model/DbSchemaSource.js'),
 	DbObject:       require ('./lib/model/DbObject.js'),
 	DbProcedure:    require ('./lib/model/DbProcedure.js'),
 	DbFunction:     require ('./lib/model/DbFunction.js'),
 	DbModel:        require ('./lib/model/DbModel.js'),
+	DbSchema:       require ('./lib/model/DbSchema.js'),
 
 	DbType:                require ('./lib/model/types/DbType.js'),
 	DbTypeArithmetic:      require ('./lib/model/types/DbTypeArithmetic.js'),

package/lib/model/DbIndex.js

@@ -22,12 +22,16 @@ class DbIndex extends DbObject {
 
 	}
 
+	get schemaName () {
+
+		return this.relation.schemaName
+
+	}
+
 	setLang (lang) {
 
 		const {relation} = this
 
-		this.schemaName = relation.schemaName
-
 		this.localName = this.originalLocalName || lang.getIndexName (relation, this)
 
 		super.setLang (lang)

package/lib/model/DbModel.js

@@ -2,12 +2,10 @@ const EventEmitter         = require ('events')
 
 const DbPool               = require ('../DbPool.js')
 const DbLang               = require ('../DbLang.js')
-const DbObjectMap          = require ('./DbObjectMap.js')
 const DbRelation           = require ('./DbRelation.js')
+const DbSchema             = require ('./DbSchema.js')
 const DbQuery              = require ('../query/DbQuery.js')
 
-const EV_MODULES_LOADED  = 'modules-loaded'
-const EV_OBJECT_CREATED  = 'object-created'
 const EV_OBJECTS_CREATED = 'objects-created'
 
 class DbModel extends EventEmitter {
@@ -16,14 +14,12 @@ class DbModel extends EventEmitter {
 	
 		super ()
 
-		let mapOptions = {}
+		this.schemata = new Map ()
 
-		for (const [k, v] of Object.entries (o)) if (v !== undefined) switch (k) {
+		let src = []; for (const [k, v] of Object.entries (o)) if (v !== undefined) switch (k) {
 
-			case 'dir':
-			case 'ext':
-			case 'merger':
-				mapOptions [k] = v
+			case 'src':
+				if (!Array.isArray (v)) src.push (v); else src = v
 				break
 
 			case 'db':
@@ -41,89 +37,111 @@ class DbModel extends EventEmitter {
 		
 		this.lang.model = this
 
-		this.map = new DbObjectMap (mapOptions)
+		for (const s of src)  this.addSchema (s)
 
-		this.on (EV_MODULES_LOADED,  ( ) => this.createObjects ())
+		if (!this.schemata.has (null)) this.addSchema ()
 
-		this.on (EV_OBJECT_CREATED,   o  => o.setLang (this.lang))
-
-		this.on (EV_OBJECTS_CREATED, ( ) => this.resolveReferences ())
+		this.on (EV_OBJECTS_CREATED, () => this.resolveReferences ())
 
 	}
-	
-	loadModules () {
 
-		this.map.load ()
-		
-		this.emit (EV_MODULES_LOADED)
+	addSchema (o = {}) {
 
-	}
-	
-	createObjects () {
+		if (typeof o === 'string') o = {root: [o]}
 
-		const {lang} = this, map = new Map ()
+		if (!o.name) o.name = null
 
-		for (const [name, pojo] of this.map.entries ()) {
+		if (this.schemata.has (o.name)) throw Error (`DbModel: the schema called ${o.name} is already registered`)
 
-			pojo.name = name
-			
-			const o = new (lang.getDbObjectClass (pojo)) (pojo)
-			
-			o.model = this
+		if (!o.schemaName) o.schemaName = o.name
 
-			this.emit (EV_OBJECT_CREATED, o)
+		for (const {schemaName} of this.schemata.values ()) if (o.schemaName === schemaName) throw Error (`DbModel: the physical name ${schemaName} is already in use`)
 
-			map.set (o.name, o)
+		o.model = this
 
-		}
-		
-		this.map = map
+		this.schemata.set (o.name, new DbSchema (o))
 
-		this.emit (EV_OBJECTS_CREATED)
+	}
+
+	getSchema (name) {
+
+		return this.schemata.get (name)
 
 	}
 
-	resolveReferences () {
+	get defaultSchema () {
 
-		for (const {columns} of this.allInstancesOf (DbRelation))
+		return this.schemata.get (null)
 
-			for (const column of Object.values (columns)) if ('reference' in column) {
+	}
 
-				const {reference} = column, {targetRelationName} = reference
+	get map () {
 
-				const targetRelation = this.map.get (targetRelationName); if (!targetRelation) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: "${targetRelationName}" not found`)
+		return this.defaultSchema.map
 
-				reference.targetRelation = targetRelation
+	}
+	
+	loadModules () {
 
-				if (!reference.targetColumnName) {
+		for (const {src} of this.schemata.values ()) if (src) src.load ()
 
-					const {pk} = targetRelation; if (!pk || pk.length !== 1) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: "${targetRelationName}"'s primary key must have exactly one column`)
+		this.emit (EV_OBJECTS_CREATED)
 
-					reference.targetColumnName = pk [0]
+	}
 
-				}
+	find (name) {
 
-				const targetColumn = targetRelation.columns [reference.targetColumnName]; if (!targetColumn) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: "${reference.targetRelationName}.${reference.targetColumnName}" not found`)
+		if (this.map.has (name)) return this.map.get (name)
 
-				reference.targetColumn = targetColumn
-				
-				column.type = targetColumn.type
-				column.typeDim = targetColumn.typeDim
+		const dot = name.indexOf ('.'); if (dot < 1) return undefined
 
-			}
+		const schema = this.getSchema (name.slice (0, dot)); if (!schema) return undefined
+
+		return schema.map.get (name.slice (dot + 1)) || undefined
 
 	}
 
-	* allInstancesOf (type) {
+	resolveReferences () {
 
-		for (const o of this.map.values ())
-		
-			if (o instanceof type)
+		for (const schema of this.schemata.values ()) {
 
-				yield o
+			for (const object of schema.map.values ()) if (object instanceof DbRelation) {
 
-	}
+				for (const column of Object.values (object.columns)) if ('reference' in column) {
+
+					const {reference} = column, {targetSchemaName, targetRelationName} = reference
+
+					const targetSchema = targetSchemaName === undefined ? schema : this.getSchema (targetSchemaName); if (!targetSchema) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: schema "${targetSchemaName}" not found`)
+
+					reference.targetSchema = targetSchema
+	
+					const targetRelation = targetSchema.map.get (targetRelationName); if (!targetRelation) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: "${targetRelationName}" not found`)
+	
+					reference.targetRelation = targetRelation
+	
+					if (!reference.targetColumnName) {
+	
+						const {pk} = targetRelation; if (!pk || pk.length !== 1) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: "${targetRelationName}"'s primary key must have exactly one column`)
+	
+						reference.targetColumnName = pk [0]
 	
+					}
+	
+					const targetColumn = targetRelation.columns [reference.targetColumnName]; if (!targetColumn) throw Error (`Cannot resolve reference from ${column.relation.name}.${column.name}: "${reference.targetRelationName}.${reference.targetColumnName}" not found`)
+	
+					reference.targetColumn = targetColumn
+					
+					column.type = targetColumn.type
+					column.typeDim = targetColumn.typeDim
+	
+				}
+	
+			}
+
+		}
+
+	}
+
 	createQuery (from, options) {
 	
 		return new DbQuery (this, from, options)
@@ -132,8 +150,6 @@ class DbModel extends EventEmitter {
 
 }
 
-DbModel.EV_MODULES_LOADED  = EV_MODULES_LOADED
-DbModel.EV_OBJECT_CREATED  = EV_OBJECT_CREATED
 DbModel.EV_OBJECTS_CREATED = EV_OBJECTS_CREATED
 
 module.exports = DbModel

package/lib/model/DbObject.js

@@ -10,28 +10,19 @@ class DbObject {
 
 			if (name.length === 0) throw Error (`name must be a non empty string`)
 
-			const pos = name.indexOf ('.')
-
-			if (pos < 0) {
-
-				this.schemaName = null
-
-				this.localName = name
-
-			}
-			else {
-
-				this.schemaName = name.slice (0, pos)
-
-				this.localName = name.slice (pos + 1)
-
-			}
+			this.localName = name
 		
 		}
 
 		for (const k in o) this [k] = o [k]
 
 	}
+
+	get schemaName () {
+
+		return 'schema' in this ? this.schema.schemaName : null
+
+	}
 	
 	setLang (lang) {
 

package/lib/model/DbReference.js

@@ -47,8 +47,27 @@ class DbReference {
 				this.on ['DELETE'] = ('default' in this.column) ? 'SET DEFAULT' : 'SET NULL'
 				break
 		}
+
+		const target = src.slice (start, -1).trim ()
+
+		const dot = target.indexOf ('.'); switch (dot) {
+
+			case -1:
+				this.targetRelationName = target
+				break 
+
+			case 0:
+				this.targetSchemaName = null
+				this.targetRelationName = target.slice (1)
+				break
+			
+			default:
+				this.targetSchemaName = target.slice (0, dot)
+				this.targetRelationName = target.slice (dot + 1)
+				break
+	
+		}
 		
-		this.targetRelationName = src.slice (start, -1).trim ()
 	
 	}
 

package/lib/model/DbSchema.js

@@ -0,0 +1,65 @@
+const DbSchemaSource = require ('./DbSchemaSource.js')
+
+class DbSchema extends require ('events') {
+	
+	constructor (o) {
+
+		super ()
+
+		if (!o.name) o.name = null
+
+		if (!o.schemaName) o.schemaName = o.name
+
+		const src = {schema: this}; for (const [k, v] of Object.entries (o)) switch (k) {
+
+			case 'model':
+			case 'schemaName':
+			case 'name':
+				this [k] = v
+				break
+
+			case 'root':
+			case 'filter':
+			case 'ext':
+			case 'merger':
+				src [k] = v
+				break
+
+			default:
+				throw new Error ('Unknown DbSchema option: ' + k)
+
+		}
+
+		if (Object.keys (src).length !== 1) this.src = new DbSchemaSource (src)
+
+		this.map = new Map ()
+
+		const {schemaName} = this
+
+		this.prefix = schemaName ? this.model.lang.quoteName (schemaName) + '.' : ''
+
+	}
+	
+	add (name, options) {
+
+		const {map, model} = this; if (map.has (name)) throw Error (`The schema already has the object named "${name}"`)
+		
+		const {lang} = model, clazz = lang.getDbObjectClass (options)
+
+		const o = new clazz ({...options, name})
+
+		o.model = model
+
+		o.schema = this
+
+		o.setLang (lang)
+
+		this.emit ('object-created', o)
+
+		map.set (name, o)
+
+	}
+	
+}
+
+module.exports = DbSchema

package/lib/model/{DbObjectMap.js → DbSchemaSource.js}

@@ -1,7 +1,7 @@
 const {ModuleLoader} = require ('doix')
 const DbObjectMerger = require ('./DbObjectMerger')
 
-class DbObjectMap extends Map {
+class DbSchemaSource extends Map {
 
 	constructor (o) {
 		
@@ -9,7 +9,23 @@ class DbObjectMap extends Map {
 		
 		let loaderOptions = {}
 
-		for (const [k, v] of Object.entries (o)) if (v !== undefined) switch (k) {
+		let {root, filter} = o; if (!root) throw Error (`DbSchemaSource: root must be provided`)
+
+		if (!Array.isArray (root)) root = [root]
+
+		o.dir = {root}
+
+		if (filter) o.dir.filter = filter
+
+		for (const [k, v] of Object.entries (o)) switch (k) {
+
+			case 'root':
+			case 'filter':
+				break
+
+			case 'schema':
+				this.schema = v
+				break
 
 			case 'dir':
 			case 'ext':
@@ -22,7 +38,7 @@ class DbObjectMap extends Map {
 				break
 
 			default:
-				throw new Error ('Unknown DbObjectMap option: ' + k)
+				throw new Error ('Unknown DbSchemaSource option: ' + k)
 
 		}
 	
@@ -40,6 +56,10 @@ class DbObjectMap extends Map {
 
 		for (const [k, v] of this.entries ()) merger.emit ('complete', v, k)
 
+		const {schema} = this
+
+		for (const [k, v] of this.entries ()) schema.add (k, v)
+
 	}
 	
 	set (k, v) {
@@ -52,4 +72,4 @@ class DbObjectMap extends Map {
 
 }
 
-module.exports = DbObjectMap
+module.exports = DbSchemaSource

package/lib/model/DbTrigger.js

@@ -14,8 +14,6 @@ class DbTrigger extends DbObject {
 
 	setLang (lang) {
 
-		this.schemaName = this.table.schemaName
-
 		this.qName = lang.quoteName (this.name)
 
 	}

package/lib/query/DbQueryTable.js

@@ -1,5 +1,3 @@
-const DbRelation = require ('../model/DbRelation.js')
-const DbQueryColumn = require ('./DbQueryColumn.js')
 const DbQueryTableColumnComparison = require ('./DbQueryTableColumnComparison.js')
 
 const JOIN_TYPES_ALOWED = ['LEFT', 'INNER', 'CROSS']
@@ -7,24 +5,22 @@ const JOIN_TYPES_ALOWED = ['LEFT', 'INNER', 'CROSS']
 class DbQueryTable {
 
 	constructor (query, sql, o = {}) {
-
-		const {model, lang} = query, {map} = model
 		
 		this.isFirst = query.tables.length === 0
 
 		this.query = query
 		
-		this.lang = lang
+		this.lang = query.lang
 		
-		if (map.has (sql)) {
+		const relation = query.model.find (sql); if (relation) {
 
-			this.relation = map.get (sql)
-			
-			this.sql = this.relation.qName
+			this.relation = relation
 
-			this.alias = o.as || sql
+			const {schema, qName, columns} = relation
 
-			const {columns} = this.relation
+			this.sql = schema.prefix + qName
+
+			this.alias = o.as || sql
 			
 			const names = o.columns || Object.keys (columns)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doix-db",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Shared database related code for doix",
   "main": "index.js",
   "files": [