🐛 extended tables referencing mutable db object + other fixes (#100)

kkharji · web-flow · commit 1c88610b902c · 2021-08-25T19:58:08.000+03:00
closes #101, #99 - `table.extend` reference db object instead of `db.extend`ed object. this fix issue with calling methods that has been already modified by the user. - remove debug stuff - modify `table.extend` mechanism. - stop mutating insert/update source data when processing for `sql.insert`
diff --git a/lua/sql.lua b/lua/sql.lua
@@ -99,7 +99,7 @@ function DB:extend(opts)
       local name = schema._name and schema._name or tbl_name
       cls[tbl_name] = schema.set_db and schema or t:extend(name, schema)
       if not cls[tbl_name].db then
-        cls[tbl_name].set_db(cls)
+        cls[tbl_name].set_db(cls.db)
       end
     end
   end
diff --git a/lua/sql/parser.lua b/lua/sql/parser.lua
@@ -418,17 +418,18 @@ end
 ---@param schema table tbl schema with extra info
 ---@return table pre processed rows
 M.pre_insert = function(rows, schema)
+  local res = {}
   rows = u.is_nested(rows) and rows or { rows }
-  for _, row in ipairs(rows) do
+  for i, row in ipairs(rows) do
     u.foreach(schema.req, function(k)
       a.missing_req_key(row[k], k)
     end)
-    u.foreach(row, function(k, v)
+    res[i] = u.map(row, function(v, k)
       local is_json = schema.types[k] == "luatable" or schema.types[k] == "json"
-      row[k] = is_json and json.encode(v) or M.sqlvalue(v)
+      return is_json and json.encode(v) or M.sqlvalue(v)
     end)
   end
-  return rows
+  return res
 end
 
 ---Postprocess data queried from a sql db. for now it is mainly used
diff --git a/lua/sql/table.lua b/lua/sql/table.lua
@@ -24,9 +24,6 @@ local run = function(func, o)
 
     if o.tbl_schema and next(o.tbl_schema) ~= nil and o.tbl_exists == false then
       o.tbl_schema.ensure = u.if_nil(o.tbl_schema.ensure, true)
-      if not o.db.create then
-        error(vim.inspect(o.db))
-      end
       o.db:create(o.name, o.tbl_schema)
     end
 
@@ -65,26 +62,22 @@ function tbl:extend(db, name, schema)
     name, db, schema = db, nil, name
   end
 
-  local t = tbl:new(db, name, { schema = schema })
+  local t = self:new(db, name, { schema = schema })
   return setmetatable({
     set_db = function(o)
-      if not o then
-        error(vim.inspect(db))
-      end
       t.db = o
     end,
   }, {
-    __index = function(_, key, ...)
-      return type(t[key]) == "function" and function(...)
-        return t[key](t, ...)
-      end or t[key]
-    end,
-    __newindex = function(_, key, val)
-      if type(val) == "function" then
-        t["_" .. key] = t[key]
-        t[key] = val
-      else
-        t[key] = val
+    __index = function(o, key, ...)
+      if type(key) == "string" then
+        key = key:sub(1, 1) == "_" and key:sub(2, -1) or key
+        if type(t[key]) == "function" then
+          return function(...)
+            return t[key](t, ...)
+          end
+        else
+          return t[key]
+        end
       end
     end,
   })
@@ -335,8 +328,5 @@ function tbl:replace(rows)
 end
 
 tbl = setmetatable(tbl, { __call = tbl.extend })
--- local db = require("sql").new "/tmp/dbfds.sql"
--- local t = tbl:extend("fatable", { id = true, name = "text" })
--- t.set_db(db)
--- print(vim.inspect(t.db))
+
 return tbl
diff --git a/test/auto/sql_spec.lua b/test/auto/sql_spec.lua
@@ -772,8 +772,8 @@ describe("sql", function()
   end)
 
   describe(":extend", function()
-    local testrui = "/tmp/extend_db"
-    local testrui2 = "/tmp/extend_db2"
+    local testrui = "/tmp/extend_db_new"
+    local testrui2 = "/tmp/extend_db_new5"
     local ok, manager
 
     it("Initialize manager", function()
@@ -803,7 +803,7 @@ describe("sql", function()
     end)
 
     it("process opts and set sql table objects", function()
-      eq("/tmp/extend_db", manager.uri, "should set self.uri.")
+      eq("/tmp/extend_db_new", manager.uri, "should set self.uri.")
       eq(true, manager.closed, "should construct without openning connection.")
       eq(nil, manager.conn, "should not set connection object.")
       eq("boolean", type(manager.sqlite_opts.foreign_keys), "should have added opts to sqlite_opts.")
@@ -833,24 +833,28 @@ describe("sql", function()
         },
       }
 
-      local id = manager.projects.insert(sqlnvim)
-
-      eq("cdata", type(manager.conn), "should set connection object.")
-      eq(1, id, "should have returned id.")
+      eq(1, manager.projects.insert(sqlnvim), "should insert and return id.")
+      eq("cdata", type(manager.conn), "should set connection object after first call to sql api")
+      eq("table", type(manager.projects.where({ id = 1 }).objectives), "should return as table.")
+      eq("table", type(sqlnvim.objectives), "It shouldn't have mutated objectives table.")
       eq(true, manager.projects.remove(), "should remove after default insert.")
 
       function manager.projects.insert()
         return manager.projects._insert(sqlnvim)
       end
-
-      local id = manager.projects.insert()
-      eq(1, id, "should have returned id.")
-
       function manager.projects.get()
-        return manager.projects._get({ where = { title = sqlnvim.title } })[1].title
+        return manager.projects._get({ where = { title = sqlnvim.title } })[1]
       end
+      function manager.projects.remove_objectives()
+        return manager.projects.update { where = { id = 1 }, set = { objectives = {} } }
+      end
+
+      eq(1, manager.projects.insert(), "should have inserted and returned id.")
 
-      eq(sqlnvim.title, manager.projects.get(), "should have inserted sqlnvim project")
+      eq(sqlnvim.title, manager.projects.get().title, "should have inserted sqlnvim project")
+      eq(true, manager.projects.get().objectives ~= "")
+      eq(true, manager.projects.remove_objectives(), "should succeed at updating")
+      eq({}, manager.projects.get().objectives, "should return empty table")
     end)
 
     it("set a different name for sql db table, with access using extend field", function()
diff --git a/test/auto/table_spec.lua b/test/auto/table_spec.lua
@@ -30,36 +30,6 @@ end
 describe("table", function()
   local t1, t2 = seed()
 
-  describe(":extend", function()
-    local t
-    it("missing db object", function()
-      ---@type SQLTableExt
-      t = tbl("tbl_name", { id = true, name = "text" })
-      eq(false, pcall(t.insert, { name = "tami" }), "should fail early.")
-      t.set_db(db)
-      eq(true, pcall(t.insert, { name = "conni" }), "should work now we have a db object to operate against.")
-      eq({ { id = 1, name = "conni" } }, t.get(), "only insert conni")
-    end)
-
-    it("with db object", function()
-      t = tbl(db, "tansactions", { id = true, amount = "real" })
-      eq(1, t.insert { amount = 20.2 })
-      eq(
-        "20.2",
-        t.map(function(row)
-          return tostring(row.amount)
-        end)[1]
-      )
-    end)
-
-    it("overwrite functions and fallback to t.db", function()
-      t.get = function()
-        return math.floor(t._get({ where = { id = 1 } })[1].amount)
-      end
-      eq(20, t.get())
-    end)
-  end)
-
   describe(":new", function()
     it("create new object with sql.table methods.", function()
       eq("table", type(t1))
@@ -537,4 +507,75 @@ describe("table", function()
       eq(true, next(tracks:get { where = { artist = 100 } }) == nil, "shouldn't be any rows referencing Dean Martin")
     end)
   end)
+
+  describe(":extend", function()
+    local t
+    it("missing db object", function()
+      ---@type SQLTableExt
+      t = tbl("tbl_name", { id = true, name = "text" })
+      eq(false, pcall(t.insert, { name = "tami" }), "should fail early.")
+      t.set_db(db)
+      eq(true, pcall(t.insert, { name = "conni" }), "should work now we have a db object to operate against.")
+      eq({ { id = 1, name = "conni" } }, t.get(), "only insert conni")
+    end)
+
+    it("with db object", function()
+      t = tbl(db, "tansactions", { id = true, amount = "real" })
+      eq(1, t.insert { amount = 20.2 })
+      eq(
+        "20.2",
+        t.map(function(row)
+          return tostring(row.amount)
+        end)[1]
+      )
+    end)
+
+    it("overwrite functions and fallback to t.db", function()
+      t.get = function()
+        return math.floor(t._get({ where = { id = 1 } })[1].amount)
+      end
+      eq(20, t.get())
+    end)
+
+    local some
+
+    it("create a new table", function()
+      some = tbl:extend(db, "somename", {
+        name = "text",
+        id = true,
+        count = {
+          type = "integer",
+          default = 0,
+        },
+      })
+    end)
+
+    it("access function", function()
+      eq("function", type(some.get), "should we still have access for")
+      eq("function", type(some._get), "should be hard coded.")
+      eq("cdata", type(some.db.conn))
+    end)
+
+    it("custom function", function()
+      function some.insert_or_update(name)
+        eq("string", type(name), "name should be a string")
+        local entry = some.where { name = name }
+        if not entry then
+          some.insert { name = name }
+        else
+          eq("function", type(some.update))
+          some.update {
+            where = { id = entry.id },
+            values = { count = entry.count + 2 },
+          }
+        end
+      end
+      -- eq({}, getmetatable(some))
+      eq("function", type(some.insert_or_update), "should be registered as function")
+      some.insert_or_update "ff"
+      -- eq("ff", some.get({ name = "ff" }).name)
+      some.insert_or_update "ff"
+      -- eq(2, some.where({ name = "ff" }).count)
+    end)
+  end)
 end)
