masterrecord 0.0.23 → 0.0.25

package/Migrations/migrationTemplate.js

@@ -1,64 +1,64 @@
-var Schema = require('./schema');
-
-
-// https://channel9.msdn.com/Blogs/EF/Migrations-Under-the-Hood
-
-
-// migration Logic
-// using the command line run the command - "add migration 'name' 'context file location' ";
-// this will call the context which will return on object of entities
-// then call the previous migration and pass that model object and the context object to the EDMModelDiffer
-// the EDMModelDiffer function to calculate database changes
-// EDMModelDiffer will return only database changes model that have not been implemented already
-// we then create the miration using function 'migrationCodeGenerator' based on the model that was provided by EDMModelDiffer
-// js date stamp Date.now()
-
-class Migration extends Schema {
-
-    constructor() {
-        super();
-    }
-
-    static up(){
-
-        this.createTable("user", {
-            id : {
-                type : "integer",
-                primary : true,
-                unique : true,
-                nullable : false
-            },
-            user_id : {
-                type : "integer",
-                required : true, // SQL Data Constraints
-                foreignKey : "user" // SQL Data Constraints
-            },
-            website_url : {
-                type : "string",
-                required : true,
-                maxLength : 60
-            },
-            website_type : {
-                type : "string",
-                required : true
-            }
-        });
-
-        this.addColumn("blog", "url", {
-            type : "string",
-            required : true
-        });
-
-        this.done();
-    }
-
-    static down(){
-        this.dropTable("user");
-
-        this.dropColumn("blog", "url");
-
-        this.done();      
-    }
-}
-
+var Schema = require('./schema');
+
+
+// https://channel9.msdn.com/Blogs/EF/Migrations-Under-the-Hood
+
+
+// migration Logic
+// using the command line run the command - "add migration 'name' 'context file location' ";
+// this will call the context which will return on object of entities
+// then call the previous migration and pass that model object and the context object to the EDMModelDiffer
+// the EDMModelDiffer function to calculate database changes
+// EDMModelDiffer will return only database changes model that have not been implemented already
+// we then create the miration using function 'migrationCodeGenerator' based on the model that was provided by EDMModelDiffer
+// js date stamp Date.now()
+
+class Migration extends Schema {
+
+    constructor() {
+        super();
+    }
+
+    static up(){
+
+        this.createTable("user", {
+            id : {
+                type : "integer",
+                primary : true,
+                unique : true,
+                nullable : false
+            },
+            user_id : {
+                type : "integer",
+                required : true, // SQL Data Constraints
+                foreignKey : "user" // SQL Data Constraints
+            },
+            website_url : {
+                type : "string",
+                required : true,
+                maxLength : 60
+            },
+            website_type : {
+                type : "string",
+                required : true
+            }
+        });
+
+        this.addColumn("blog", "url", {
+            type : "string",
+            required : true
+        });
+
+        this.done();
+    }
+
+    static down(){
+        this.dropTable("user");
+
+        this.dropColumn("blog", "url");
+
+        this.done();      
+    }
+}
+
 module.exports = Migration;

package/Migrations/migrations.js

@@ -1,23 +1,66 @@
-// version 1
-var fs = require('fs');
-// https://blog.tekspace.io/code-first-multiple-db-context-migration/
-
-// node masterrecord add-migration josh C:\Users\rbatista\Downloads\kollege\freshmen\app\models\context
-class Migrations{
-
-    EDMModelDiffer(snapShot, contextModel){
-            
-        // do a diff and return only diff fields
-        // if table doesnt exist then add a create database object.
-    }
-
-    migrationCodeGenerator(name, column, migrationDate){
-        // will create migration file with data needed
-        // using the migration template
-
-    }
-
-
-}
-
+// version 1
+var fs = require('fs');
+// https://blog.tekspace.io/code-first-multiple-db-context-migration/
+
+// node masterrecord add-migration josh C:\Users\rbatista\Downloads\kollege\freshmen\app\models\context
+class Migrations{
+
+    EDMModelDiffer(snapShots, tableList){
+        new schemaList = []
+        const tableKeyList = Object.keys(tableList);
+        // loop through tables
+        for (const tableKey of tableKeyList) {
+            // check if table has already been migrated
+            var tableSnapShot = snapShots[tableKey];
+            if(tableSnapShot){
+                // check if we have the column in the sceama
+                const columnKeyList = Object.keys(tableKey);
+                // loop through tables
+                for (const columnKey of columnKeyList) {
+                    var newTable = {};
+                    if(tableSnapShot[columnKey]){
+
+                        /*
+                            id : {
+                                nullabale : true,
+                                type : string
+                            }
+
+                            id : {
+                                nullabale : true,
+                                type : int,
+                                unique : true
+                            }
+                        
+                        */
+                        // if we then check if we have all the same types
+                        // loop through schema list
+                        // check if we have the same in the context
+                        // if the same then check if if value is diffrent
+                        // then delete from context
+                        // after loop complete wahtever left in conext just push to object
+                    }
+                    else{
+                        // if we dont have it then add it to the
+                        newTable[columnKey] = tableKey[columnKey];
+                        schemaList.push(newTable);
+                    }  
+                }
+            }else{
+                schemaList.push(contextKeys[key]);
+            }
+            
+           
+        }
+    }
+
+    migrationCodeGenerator(name, column, migrationDate){
+        // will create migration file with data needed
+        // using the migration template
+
+    }
+
+
+}
+
 module.exports = Migrations;

package/Migrations/schema.js

@@ -1,43 +1,43 @@
-// version 1
-var fs = require('fs');
-
-class Schema{
-
-    // create obj to convert into create sql
-    addColumn(tableName, columnName, ){
-
-        // add column to database
-    }
-
-    dropColumn(tableName, columnName){
-        // drop column 
-
-    }
-
-    createTable(name, columns){
-
-    }
-
-    dropTable(name){
-
-    }
-
-    // will get the data and create the file
-    done(){
-
-
-    }
-}
-
-
-/*
-    up and down function..
-    on commmand line call of run migrations with folder location of context. it will
-    load context and all the objects.
-    it will then match objects with migration data. 
-    if it's a new item it will generate a new migration dependent on what comes from migration. 
-    
-
-*/
-
+// version 1
+var fs = require('fs');
+
+class Schema{
+
+    // create obj to convert into create sql
+    addColumn(tableName, columnName, ){
+
+        // add column to database
+    }
+
+    dropColumn(tableName, columnName){
+        // drop column 
+
+    }
+
+    createTable(name, columns){
+
+    }
+
+    dropTable(name){
+
+    }
+
+    // will get the data and create the file
+    done(){
+
+
+    }
+}
+
+
+/*
+    up and down function..
+    on commmand line call of run migrations with folder location of context. it will
+    load context and all the objects.
+    it will then match objects with migration data. 
+    if it's a new item it will generate a new migration dependent on what comes from migration. 
+    
+
+*/
+
 module.exports = Schema;

package/QueryLanguage/queryManager.js

@@ -0,0 +1,66 @@
+// ALL THIS SHOULD DO IS BUILD A SQL QUERY
+// version 1.0.1
+
+class queryManager{
+    constructor( query) {
+
+        /*
+            queryObject
+            {
+                "where": where user.id = 1
+                "raw": "select * from tablename where user.id = 2" OR false,
+                "builder": builderObject,
+                "select" : "*",
+                "from" : from tablename
+            }
+        */
+        this._query = query;
+        this._queryBuilder = query.builder;
+        this._context = query.builder.__context;
+    }
+    
+    single(){
+        var entityValue = this._context._SQLEngine.get(this._query.getScript());
+        var sing = this._queryBuilder.__execute(entityValue, this._queryBuilder);
+        return sing;
+    }
+
+    //
+    select(query){
+       // this will come after the where
+       this._query.select = "select " + query;
+       return this;
+    }
+    
+    count(){
+        // trying to match string select and relace with select Count(*);
+        var res = this._query.select.replace("select *", "select Count(*)");
+        var entityValue = this._context._SQLEngine.get(res);
+        var val = entityValue[Object.keys(entityValue)[0]];
+        return val;
+    }
+
+    toList(){
+        var entityValue = this._context._SQLEngine.all(this._query);
+        var toLi = this._queryBuilder.__executeList(entityValue, this._queryBuilder);
+        return toLi;
+    }
+
+}
+
+module.exports = queryManager;
+
+
+/*
+
+LINQ Extension Methods
+First()
+FirstOrDefault()
+SingleOrDefault()
+Count()
+Min()
+Max()
+Last()
+LastOrDefault()
+Average()
+*/

package/QueryLanguage/queryMethods.js

@@ -0,0 +1,171 @@
+// ALL THIS SHOULD DO IS BUILD A SQL QUERY
+// version 1.0.222
+// TODO: change name of queryManager to select manager;
+var entityTrackerModel = require('masterrecord/Entity/EntityTrackerModel');
+var tools = require('masterrecord/Tools');
+var queryScript = require('masterrecord/QueryLanguage/queryScript');
+
+class queryMethods{
+
+    constructor(entity, context) {
+        this.__entity = entity;
+        this.__context = context;
+        this.__queryObject = new queryScript();
+    }
+
+    // build a single entity
+    __singleEntityBuilder(dataModel){
+        var $that = this;
+        if(dataModel){
+            var ent = new entityTrackerModel();
+            var mod = ent.build(dataModel, $that.__entity, $that.__context);
+            mod.__state = "track";
+            $that.__context.__track(mod);
+            return mod;
+        }else{
+            return null;
+        }
+    }
+
+    // build multiple entities
+    __multipleEntityBuilder(entityValue){
+        var $that = this;
+        var listArray = [];
+        if(entityValue){
+            for(let i = 0; i < entityValue.length; i++){
+                listArray.push($that.__singleEntityBuilder(entityValue[i]));
+             }
+             return listArray;
+        }else{
+            return null;
+        }
+    }
+
+    __reset(){
+        this.__queryObject.reset();
+    }
+
+    raw(query){
+
+        this.__queryObject.raw(query);
+        return this;
+    }
+
+    where(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.where(str, this.__entity.__name);
+        return this;
+    }
+
+    // when you dont want to use lazy loading and want it called at that moment
+    //Eagerly loading
+    include(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.include(str, this.__entity.__name);
+        return this;
+    }
+
+    // only takes a array of selected items
+    select(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.select(str, this.__entity.__name);
+        return this;
+    }
+
+
+
+    // do join on two tables = inner join
+    join(){
+
+    }
+
+    skip(){
+
+    }
+
+    limit(){
+
+    }
+
+    oderBy(){
+
+    }
+
+    groupBy(){
+        
+    }
+
+    contains(){
+            // https://entityframework.net/knowledge-base/3491721/linq-to-entities---where-in-clause-in-query
+    }
+
+    count(){
+        // trying to match string select and relace with select Count(*);
+        var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
+        var val = entityValue[Object.keys(entityValue)[0]];
+        this.__reset();
+        return val;
+    }
+
+    single(){
+        var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
+        var sing = this.__singleEntityBuilder(entityValue, this._queryBuilder);
+        this.__reset();
+        return sing;
+    }
+
+    toList(){
+        var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
+        var toLi = this.__multipleEntityBuilder(entityValue, this._queryBuilder);
+        this.__reset();
+        return toLi;
+    }
+
+    asQueryable(){
+        // returns the sql created and does not make a call to DB
+    }
+
+    add(entityValue){
+        // This will call context API to REMOVE entity to update list
+        tools.clearAllProto(entityValue);
+        entityValue.__state = "insert";
+        entityValue.__entity = this.__entity;
+        entityValue.__context = this.__context;
+        this.__context.__track(entityValue);
+    }
+    
+    remove(entityValue){
+        entityValue.__state = "delete";
+        entityValue.__entity = this.__entity;
+        entityValue.__context = this.__context;
+    }
+
+    track(entityValue){
+        entityValue.__state = "track";
+        tools.clearAllProto(entityValue);
+        entityValue.__entity = this.__entity;
+        entityValue.__context = this.__context;
+        this.__context.__track(entityValue);
+    }
+}
+
+module.exports = queryMethods;
+