@keltoi/hydra 1.1.8 → 1.2.0

package/index.js

@@ -1 +1 @@
-"use strict";var e=require("knex"),t=require("axios");class Model{#e;constructor(e={}){this.#e=e}get key(){return this.#e}set key(e={}){this.#e=e}get entity(){return{}}static build(e={}){return new Model(e)}}class Logged extends Model{#t=new Date;constructor({key:e={},createdAt:t=new Date}){super(e),this.#t=t}get createdAt(){return this.#t}set createdAt(e=new Date){this.createdAt=e}static makeMe(t=e(),s=Logged,n=(t=new e.TableBuilder)=>{}){return t.schema.createTable(s.name,(e=>{n(e),e.dateTime("createdAt").notNullable().defaultTo(t.fn.now())}))}}class Traced extends Logged{#s=void 0|new Date;#n=!0;constructor({key:e={},createdAt:t=new Date,updatedAt:s=void 0|new Date,active:n=!0}){super({key:e,createdAt:t}),this.#n=n,this.#s=s}get updatedAt(){return this.#s}set updatedAt(e=new Date){this.#s=e}get active(){return this.#n}set active(e=!0){this.#n=e}tickUpdateNow(){this.#s=new Date}static makeMe(t=e(),s=Traced,n=(t=new e.TableBuilder)=>{}){return t.schema.createTable(s.name,(e=>{n(e),e.dateTime("createdAt").notNullable().defaultTo(t.fn.now()),e.dateTime("updatedAt").nullable(),e.boolean("active").defaultTo(!0)}))}}class Linking{#r=new Model;#i=new Model;#a=Model;#o=Model;get Abscissa(){return this.#a}get Ordinate(){return this.#o}static build=({abscissa:e=new Model,ordinate:t=new Model})=>new Linking(Model,Model,{abscissa:e,ordinate:t});constructor(e=Model,t=Model,{abscissa:s=e.build(),ordinate:n=t.build()}){this.#a=e,this.#o=t,this.#r=s,this.#i=n}static makeMe(t=e(),s=Model,n=Model,r=(t=new e.TableBuilder)=>{}){return t.schema.createTable(`${s.name}${n.name}`,(e=>{r(e)}))}get abscissaKey(){return{idAbscissa:this.#r.key.id}}get ordinateKey(){return{idOrdinate:this.#i.key.id}}get key(){return{...this.abscissaKey,...this.ordinateKey}}get abscissa(){return this.#r}set abscissa(e=new Model){this.#r=e}get ordinate(){return this.#i}set ordinate(e=new Model){this.ordinate=e}}class Thing extends Model{#d;constructor({key:e={},name:t=""}){super(e),this.#d=t}get name(){return this.#d}set name(e=""){this.#d=e}get entity(){return{name:this.#d}}static makeMe(t=e(),s=Thing,n=(t=new e.TableBuilder)=>{}){return t.schema.createTable(s.name,(e=>{n(e),e.string(255).notNullable()}))}}let s=class Context{#c;constructor(t=e()){this.#c=t}get db(){return this.#c}unitOfWork(...e){return this.#c.transaction().then((t=>{e.forEach((e=>e.context=t));const clean=()=>e.forEach((e=>e.resetContext()));return{done:()=>t.commit().then(clean),rollback:()=>t.rollback().then(clean)}}))}static instance(t=e()){return new Context(t)}async terraform(e=[]){const t=e.map((async e=>{await this.#c.schema.hasTable(e.name)||await e.makeMe(this.#c)}));await Promise.all(t)}},n=class Repository{#d="";myContext;static anyOrError(e,t={code:0,message:""}){if(e)return e;throw t}static setOrEmpty(e=[],t=e=>e){return e.length?e.map(t):[]}constructor(e=Model,t=new s){this.#d=e.name,this.myContext=()=>t.db(this.#d),this.resetContext=()=>{this.myContext=()=>t.db(this.#d)},this.modelInstance=(t={})=>e.build(t)}set context(t=e()){this.myContext=()=>t(this.#d)}create=(e=new Model)=>this.myContext().insert({...e.key,...e.entity}).then((()=>e));insert=(e=new Model)=>this.myContext().insert(e.entity,Object.keys(e.key)).then((t=>e.key=t[0])).then((()=>e));update=(e=new Model)=>this.myContext().where(e.key).update(e.entity).then((e=>e>0));delete=(e={})=>this.myContext().where(e).del().then((e=>e>0));get=(e={})=>this.myContext().where(e).first().then((e=>Repository.anyOrError(e,{code:404,message:"Not found"}))).then(this.modelInstance);list=()=>this.myContext().select().then((e=>Repository.setOrEmpty(e,this.modelInstance)))};class Context{#h;constructor(e=t.create({})){this.#h=e}get http(){return this.#h}}class Repository{#l;constructor(e=Model,t=new Context){this.#l=t,this.modelInstance=(t={})=>new e(t)}static queryString(e={}){return"?"+Object.entries(e).map((([e,t])=>`${e}=${t}`)).join("&")}get context(){return this.#l}}exports.ApiContext=Context,exports.ApiRepository=Repository,exports.ApiRestRepository=class RestRepository extends Repository{constructor(e=Model,t=new Context){super(e,t)}#m=(e="",t=void 0|{})=>this.context.http.get(t?`${e}${Repository.queryString(t)}`:e);get=(e="",t=void 0|{})=>this.#m(e,t).then((e=>this.modelInstance(e)));list=(e="",t=void 0|{})=>this.#m(e,t).then(((e=[])=>e.map((e=>this.modelInstance(e)))));create=(e="",t=new Model)=>this.context.http.post(e,t.entity);update=(e="",t=new Model)=>this.context.http.put(e,t.entity);change=(e="",t=new Model)=>this.context.http.patch(e,t.entity);delete=(e,t=new Model)=>this.context.http.delete(`/${e}`)},exports.DbContext=s,exports.DbLinked=class DbLinked{#y;#d="";myContext;constructor(e=Linking,t=new s){this.#d=e.name,this.myContext=()=>t.db(this.#d),this.#y=e}#u=(e=[new Linking])=>this.myContext().insert(e.map((e=>e.key()))).then((()=>e));insert=(e=new Linking)=>{const t=e.key();return this.myContext().insert(t).then((()=>t))};insertOrdinatesByAbscissa=(e=new Model,t=[new Model])=>{const s=t.map((t=>this.#y.build({abscissa:e,o:t})));return this.#u(s)};insertAbscissasByOrdinate=(e=new Model,t=[new Model])=>{const s=t.map((t=>this.#y.build({a:t,ordinate:e})));return this.#u(s)};delete=(e=new Linking)=>this.myContext().where(e.key()).del().then((e=>e>0));abscissasByOrdinate=(e=new Linking)=>{const t=e.Abscissa,s=Object.keys(e.abscissaKey),n=s.map((e=>`${this.#d}.${e}`)),r=s.map((e=>`${t.name}.${e}`));return this.myContext().where(e.ordinateKey).select(n).join(t.name,(e=>n.forEach(((t,s)=>{e.on(t,r[s])})))).then((e=>e.map((e=>t.build(e)))))};ordinatesByAbscissa=(e=new Linking)=>{const t=e.Ordinate,s=Object.keys(e.ordinateKey),n=s.map((e=>`${this.#d}.${e}`)),r=s.map((e=>`${t.name}.${e}`));return this.myContext().where(e.abscissaKey).select(n).join(t.name,(e=>n.forEach(((t,s)=>{e.on(t,r[s])})))).then((e=>e.map((e=>t.build(e)))))}},exports.DbLoggedRepository=class TracedRepository extends n{constructor(e=Traced,t=new s){super(e,t)}deceased=()=>this.myContext().where({active:!1}).select().then((e=>n.setOrEmpty(e,this.modelInstance)));get=(e={})=>this.myContext().where({...e,active:!0}).first().then((e=>n.anyOrError(e,{code:404,message:"Not found"}))).then(this.modelInstance);before=(e=new Date)=>this.myContext().where("createdAt","<",e.toISOString()).select().then((e=>n.setOrEmpty(e,this.modelInstance)));after=(e=new Date)=>this.myContext().where("createdAt",">",e.toISOString()).select().then((e=>n.setOrEmpty(e,this.modelInstance)));list=()=>this.myContext().select().orderBy("createdAt","updatedAt").where({active:!0}).then((e=>n.setOrEmpty(e,this.modelInstance)));update=(e=new Logged)=>this.myContext().where(e.key).update({...e.entity,updatedAt:(new Date).toISOString()}).then((e=>e>0));delete=(e={})=>this.myContext().where(e).update({active:!1,updatedAt:(new Date).toISOString()}).then((e=>e>0))},exports.DbRepository=n,exports.DbThingRepository=class ThingRepository extends n{constructor(e=new s){super(model=Thing,e)}getByName=(e="")=>this.myContext().where({name:e}).select().then((e=>n.setOrEmpty(e,this.modelInstance)))},exports.DbTracedRepository=class TracedRepository extends n{constructor(e=Traced,t=new s){super(e,t)}before=(e=new Date)=>this.myContext().where("createdAt","<",e.toISOString()).select().then((e=>n.setOrEmpty(e,this.modelInstance)));after=(e=new Date)=>this.myContext().where("createdAt",">",e.toISOString()).select().then((e=>n.setOrEmpty(e,this.modelInstance)));list=()=>this.myContext().select().orderBy("createdAt").then((e=>n.setOrEmpty(e,this.modelInstance)));last=()=>this.myContext().first().orderBy("createdBy",order="desc").then((e=>n.anyOrError(e,{code:400,message:"Not found"})));first=()=>this.myContext().first().orderBy("createdBy",order="asc").then((e=>n.anyOrError(e,{code:400,message:"Not found"})));create=(e=new Traced)=>this.myContext().insert({...e.entity,createdAt:(new Date).toISOString()},Object.keys(model.key)).then((e=>model.key=e[0])).then((()=>model))},exports.Handler=class Handler{#l;constructor({context:e=new s}){this.#l=e}get context(){return this.#l}handle(){}handleError({code:e,message:t}){return Promise.reject({code:e,message:t})}},exports.Linking=Linking,exports.Logged=Logged,exports.Model=Model,exports.Service=class Service{#l;constructor(e=new s){this.#l=e}get context(){return this.#l}handleError=(e,t)=>Promise.reject({code:e,message:t});handleFailure=e=>this.handleError({code:500,message:e.message})},exports.Thing=Thing,exports.Traced=Traced;
+"use strict";var e=require("knex"),t=require("axios");class Model{#e;constructor(e={}){this.#e=e}get key(){return this.#e}set key(e={}){this.#e=e}get entity(){return{}}static build(e={}){return new Model(e)}}var runWhenFalse=(e=Promise.resolve(!0),t=async()=>{})=>e.then((async e=>{e||await t()}));class Logged extends Model{#t=new Date;constructor({key:e={},createdAt:t=new Date}){super(e),this.#t=t}get createdAt(){return this.#t}set createdAt(e=new Date){this.createdAt=e}static makeMe(t=e(),s=Logged,n=(t=new e.TableBuilder)=>{}){return runWhenFalse(t.schema.hasTable(s.name),(()=>t.schema.createTable(s.name,(e=>{n(e),e.dateTime("createdAt").notNullable().defaultTo(t.fn.now())}))))}}class Traced extends Logged{#s=void 0|new Date;#n=!0;constructor({key:e={},createdAt:t=new Date,updatedAt:s=void 0|new Date,active:n=!0}){super({key:e,createdAt:t}),this.#n=n,this.#s=s}get updatedAt(){return this.#s}set updatedAt(e=new Date){this.#s=e}get active(){return this.#n}set active(e=!0){this.#n=e}tickUpdateNow(){this.#s=new Date}static makeMe(t=e(),s=Traced,n=(t=new e.TableBuilder)=>{}){return super.makeMe(t,s,(e=>{n(e),e.dateTime("updatedAt").nullable(),e.boolean("active").defaultTo(!0)}))}}class Linking{#r=new Model;#i=new Model;#a=Model;#o=Model;get Abscissa(){return this.#a}get Ordinate(){return this.#o}constructor(e=Model,t=Model,{abscissa:s=new e,ordinate:n=new t}){this.#a=e,this.#o=t,this.#r=s,this.#i=n}static build=({AbscissaModel:e=Model,OrdinateModel:t=Model,abscissa:s=new Model,ordinate:n=new Model})=>new Linking(e,t,{abscissa:s,ordinate:n});static makeMe(t=e(),s=Model,n=Model,r=(t=new e.TableBuilder)=>{}){const i=`${s.name}${n.name}`;return runWhenFalse(t.schema.hasTable(i),(()=>t.schema.createTable(i,(e=>{r(e)}))))}get abscissaKey(){return{idAbscissa:this.#r.key}}get ordinateKey(){return{idOrdinate:this.#i.key}}get key(){return{...this.abscissaKey,...this.ordinateKey}}get entity(){}get abscissa(){return this.#r}set abscissa(e=this.Abscissa.build()){this.#r=e}get ordinate(){return this.#i}set ordinate(e=this.Ordinate.build()){this.ordinate=e}}class Thing extends Model{#d;constructor({key:e={},name:t=""}){super(e),this.#d=t}get name(){return this.#d}set name(e=""){this.#d=e}get entity(){return{name:this.#d}}static makeMe(t=e(),s=Thing,n=255,r=(t=new e.TableBuilder)=>{}){return runWhenFalse(t.schema.hasTable(s.name),(()=>t.schema.createTable(s.name,(e=>{r(e),e.string(n).notNullable()}))))}}let s=class Context{#c;constructor(t=e()){this.#c=t}get db(){return this.#c}unitOfWork(...e){return this.#c.transaction().then((t=>{e.forEach((e=>e.context=t));const clean=()=>e.forEach((e=>e.resetContext()));return{done:()=>t.commit().then(clean),rollback:()=>t.rollback().then(clean)}}))}static instance(t=e()){return new Context(t)}async terraform(e=[]){const t=e.map((async e=>e.makeMe(this.#c)));console.log("Terraforming..."),await Promise.all(t)}},n=class Repository{#d="";myContext;Entity=Model;static anyOrError(e,t={code:0,message:""}){if(e)return e;throw t}static setOrEmpty(e=[],t=e=>e){return e.length?e.map(t):[]}constructor(e=Model,t=new s){this.#d=e.name,this.myContext=()=>t.db(this.#d),this.resetContext=()=>{this.myContext=()=>t.db(this.#d)},this.Entity=e}set context(t=e()){this.myContext=()=>t(this.#d)}create=(e=new Model)=>this.myContext().insert({...e.key,...e.entity}).then((()=>e));insert=(e=new Model)=>this.myContext().insert(e.entity,Object.keys(e.key)).then((t=>(e.key=t[0],e)));update=(e=new Model)=>this.myContext().where(e.key).update(e.entity).then((e=>e>0));delete=(e=new Model)=>this.myContext().where(e.key).del().then((e=>e>0));get=(e=new Model)=>this.myContext().where(e.key).first().then((e=>Repository.anyOrError(e,{code:404,message:"Not found"}))).then(this.Entity.build);list=()=>this.myContext().select().then((e=>Repository.setOrEmpty(e,this.Entity.build)))};class Context{#h;constructor(e=t.create({})){this.#h=e}get http(){return this.#h}}class Repository{#y;constructor(e=Model,t=new Context){this.#y=t,this.modelInstance=(t={})=>new e(t)}static queryString(e={}){return"?"+Object.entries(e).map((([e,t])=>`${e}=${t}`)).join("&")}get context(){return this.#y}}exports.ApiContext=Context,exports.ApiRepository=Repository,exports.ApiRestRepository=class RestRepository extends Repository{constructor(e=Model,t=new Context){super(e,t)}#l=(e="",t=void 0|{})=>this.context.http.get(t?`${e}${Repository.queryString(t)}`:e);get=(e="",t=void 0|{})=>this.#l(e,t).then((e=>this.modelInstance(e)));list=(e="",t=void 0|{})=>this.#l(e,t).then(((e=[])=>e.map((e=>this.modelInstance(e)))));create=(e="",t=new Model)=>this.context.http.post(e,t.entity);update=(e="",t=new Model)=>this.context.http.put(e,t.entity);change=(e="",t=new Model)=>this.context.http.patch(e,t.entity);delete=(e,t=new Model)=>this.context.http.delete(`/${e}`)},exports.DbContext=s,exports.DbLinked=class DbLinked{#m;#d="";myContext;constructor(e=Linking,t=new s){this.#d=e.name,this.myContext=()=>t.db(this.#d),this.#m=e}createBatch=(e=[new Linking])=>this.myContext().insert(e.map((e=>({...e.key,...e.entity})))).then((()=>e));create=(e=new Linking)=>this.myContext().insert({...e.key,...e.entity}).then((()=>e));insertOrdinatesByAbscissa=({abscissa:e=new Model,ordinates:t=[new Model]})=>{const s=t.map((t=>this.#m.build({abscissa:e,ordinate:t})));return this.createBatch(s)};insertAbscissasByOrdinate=({ordinate:e=new Model,abscissas:t=[new Model]})=>{const s=t.map((t=>this.#m.build({abscissa:t,ordinate:e})));return this.createBatch(s)};delete=(e=new Linking)=>this.myContext().where(e.key).del().then((e=>e>0));getAbscissasByOrdinate(e=new Linking){const t=e.Abscissa,s=e.Ordinate,n=Object.keys(e.abscissaKey),r=Object.keys(e.abscissa.key),i=n.map((e=>`${t.name}${s.name}.${e}`)),a=r.map((e=>`${t.name}.${e}`));return this.myContext().where(e.ordinateKey).select(`${t.name}.*`).join(t.name,(e=>i.forEach(((t,s)=>{e.on(t,a[s])})))).then((e=>e.map((e=>t.build(e)))))}getOrdinatesByAbscissa(e=new Linking){const t=e.Ordinate,s=e.Abscissa,n=Object.keys(e.ordinateKey),r=Object.keys(e.ordinate.key),i=n.map((e=>`${s.name}${t.name}.${e}`)),a=r.map((e=>`${t.name}.${e}`));return this.myContext().where(e.abscissaKey).select(`${t.name}.*`).join(t.name,(e=>i.forEach(((t,s)=>{e.on(t,a[s])})))).then((e=>e.map((e=>t.build(e)))))}},exports.DbLoggedRepository=class LoggedRepository extends n{constructor(e=Logged,t=new s){super(e,t)}get=(e=new Logged)=>this.myContext().where({...e.key}).first().then((e=>n.anyOrError(e,{code:404,message:"Not found"}))).then(this.Entity.build);before=(e=new Date,t="asc")=>this.myContext().where("createdAt","<",e.toISOString()).select().orderBy("createdAt",t).then((e=>n.setOrEmpty(e,this.Entity.build)));after=(e=new Date,t="asc")=>this.myContext().where("createdAt",">",e.toISOString()).select().orderBy("createdAt",t).then((e=>n.setOrEmpty(e,this.Entity.build)));list=(e="asc")=>this.myContext().select().orderBy("createdAt",e).then((e=>n.setOrEmpty(e,this.Entity.build)));insert=(e=new Logged)=>this.myContext().insert({...e.entity,createdAt:(new Date).toISOString()},Object.keys(e.key)).then((t=>e.key=t[0])).then((()=>e));create=(e=new Logged)=>this.myContext().insert({...e.entity,createdAt:(new Date).toISOString()}).then((()=>e));update=()=>Promise.reject(new Error("Cannot update a logged object"));delete=()=>Promise.reject(new Error("Cannot delete a logged object"))},exports.DbRepository=n,exports.DbThingRepository=class ThingRepository extends n{constructor(e=Thing,t=new s){super(e,t)}getByName=(e="")=>this.myContext().where({name:e}).select().then((e=>n.setOrEmpty(e,this.Entity.build)))},exports.DbTracedRepository=class TracedRepository extends n{constructor(e=Traced,t=new s){super(e,t)}deceased=(e="asc")=>this.myContext().where({active:!1}).select().orderBy(["createdAt","updatedAt"],e).then((e=>n.setOrEmpty(e,this.Entity.build)));before=(e=new Date,t="asc")=>this.myContext().where("createdAt","<",e.toISOString()).where({active:!0}).select().orderBy(["createdAt","updatedAt"],t).then((e=>n.setOrEmpty(e,this.Entity.build)));after=(e=new Date,t="asc")=>this.myContext().where("createdAt",">",e.toISOString()).where({active:!0}).select().orderBy(["createdAt","updatedAt"],t).then((e=>n.setOrEmpty(e,this.Entity.build)));list=(e="asc")=>this.myContext().where({active:!0}).select().orderBy(["createdAt","updatedAt"],e).then((e=>n.setOrEmpty(e,this.Entity.build)));last=()=>this.myContext().where({active:!0}).first().orderBy("createdAt","desc").then((e=>n.anyOrError(e,{code:404,message:"Not found"})));first=()=>this.myContext().where({active:!0}).first().orderBy("createdAt","asc").then((e=>n.anyOrError(e,{code:404,message:"Not found"})));insert=(e=new Traced)=>this.myContext().insert({...e.entity,createdAt:(new Date).toISOString()},Object.keys(e.key)).then((t=>e.key=t[0])).then((()=>e));create=(e=new Traced)=>this.myContext().insert({...e.key,...e.entity,createdAt:(new Date).toISOString()}).then((()=>e));update=(e=new Traced)=>this.myContext().where(e.key).update({...e.entity,updatedAt:(new Date).toISOString()}).then((e=>e>0));delete=(e=new Traced)=>this.myContext().where(e.key).update({active:!1,updatedAt:(new Date).toISOString()}).then((e=>e>0))},exports.Handler=class Handler{#y;constructor({context:e=new s}){this.#y=e}get context(){return this.#y}handle(){}handleError({code:e,message:t}){return Promise.reject({code:e,message:t})}},exports.Linking=Linking,exports.Logged=Logged,exports.Model=Model,exports.Service=class Service{#y;constructor(e=new s){this.#y=e}get context(){return this.#y}handleError=(e,t)=>Promise.reject({code:e,message:t});handleFailure=e=>this.handleError({code:500,message:e.message})},exports.Thing=Thing,exports.Traced=Traced,exports.runWhenFalse=runWhenFalse,exports.runWhenTrue=(e=Promise.resolve(!0),t=async()=>{})=>e.then((async e=>{e&&await t()}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keltoi/hydra",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "description": "Boilerplate to start your API from zero using Repository Pattern",
   "main": "index.js",
   "scripts": {

package/src/helper/runWhenFalse.js

@@ -0,0 +1,7 @@
+export default (
+        cond = Promise.resolve(true),
+        execute = async () => {},
+)=>cond
+.then(async isTrue=>{
+    if (!isTrue) await execute()
+})

package/src/helper/runWhenTrue.js

@@ -0,0 +1,7 @@
+export default (
+        cond = Promise.resolve(true),
+        execute = async () => {},
+)=>cond
+.then(async isTrue=>{
+    if (isTrue) await execute()
+})

package/src/index.js

@@ -14,6 +14,8 @@ import ApiRepository from './repository/api/index.js'
 import ApiRestRepository from './repository/api/restRepository.js'
 import Service from './service/index.js'
 import Handler from './handler/index.js'
+import runWhenTrue from './helper/runWhenTrue.js'
+import runWhenFalse from './helper/runWhenFalse.js'
 
 export {
     Model,
@@ -31,5 +33,7 @@ export {
     ApiRepository,
     ApiRestRepository,
     Service,
-    Handler
+    Handler,
+    runWhenTrue,
+    runWhenFalse
 }

package/src/model/linking.js

@@ -1,5 +1,6 @@
 import knex, { TableBuilder } from "knex"
 import Model from "./index"
+import runWhenFalse from "../helper/runWhenFalse"
 
 export default class Linking{
     #abscissa=new Model()
@@ -16,17 +17,12 @@ export default class Linking{
         return this.#OrdinateModel
     }
 
-    static build=({
-        abscissa=new Model(),
-        ordinate=new Model()
-    })=>new Linking(Model,Model,{abscissa,ordinate})
-
     constructor(
         AbscissaModel=Model,
         OrdinateModel=Model,
         {
-            abscissa = AbscissaModel.build(),
-            ordinate = OrdinateModel.build()
+            abscissa = new AbscissaModel(),
+            ordinate = new OrdinateModel()
         })
     {
         this.#AbscissaModel = AbscissaModel
@@ -36,27 +32,39 @@ export default class Linking{
         this.#ordinate = ordinate
     }
 
+    static build=({
+        AbscissaModel=Model,
+        OrdinateModel=Model,
+        abscissa=new Model(),
+        ordinate=new Model()
+    })=>new Linking(AbscissaModel,OrdinateModel,{abscissa,ordinate})
+
     static makeMe(
         db=knex(),
         abscissa=Model,
         ordinate=Model,
-        schema=(t=new knex.TableBuilder())=>{}
+        schema=(t=new TableBuilder())=>{}
     ){
-        return db.schema
-            .createTable(
-                `${abscissa.name}${ordinate.name}`,
+        const tableName = `${abscissa.name}${ordinate.name}`
+
+        return runWhenFalse(
+            db.schema.hasTable(tableName),
+            () => db.schema.createTable(
+                tableName,
                 table=>{
                     schema(table)
                 }
             )
+        )
     }
 
+
     get abscissaKey(){
-        return { idAbscissa: this.#abscissa.key['id'] }
+        return { idAbscissa: this.#abscissa.key }
     }
 
     get ordinateKey(){
-        return { idOrdinate: this.#ordinate.key['id'] }
+        return { idOrdinate: this.#ordinate.key }
     }
 
     get key(){
@@ -66,10 +74,12 @@ export default class Linking{
         }
     }
 
+    get entity(){}
+
     get abscissa(){ return this.#abscissa }
-    set abscissa(value = new Model()){ this.#abscissa = value }
+    set abscissa(value = this.Abscissa.build()){ this.#abscissa = value }
 
     get ordinate(){ return this.#ordinate }
-    set ordinate(value = new Model()){ this.ordinate = value }
+    set ordinate(value = this.Ordinate.build()){ this.ordinate = value }
 
 }

package/src/model/logged.js

@@ -1,5 +1,8 @@
-import knex, { TableBuilder } from "knex"
+import knex, { Knex, TableBuilder } from "knex"
 import Model from "./index.js"
+import createTableIfNotExists from "../helper/runWhenTrue.js"
+import runWhenTrue from "../helper/runWhenTrue.js"
+import runWhenFalse from "../helper/runWhenFalse.js"
 
 export default class Logged extends Model{
     #createdAt=new Date()
@@ -10,7 +13,7 @@ export default class Logged extends Model{
     }){
         super(key)
         this.#createdAt = createdAt
-    }
+    } 
 
     get createdAt(){ return this.#createdAt }
     set createdAt(value = new Date()){ this.createdAt = value }
@@ -20,8 +23,9 @@ export default class Logged extends Model{
         model=Logged,
         schema=(t=new TableBuilder())=>{}
     ){
-        return db.schema
-            .createTable(
+        return runWhenFalse(
+            db.schema.hasTable(model.name),
+            ()=>db.schema.createTable(
                 model.name,
                 table=>{
                     schema(table)
@@ -31,5 +35,6 @@ export default class Logged extends Model{
                         .defaultTo(db.fn.now())
                 }
             )
+        )
     }
 }

package/src/model/status.js

@@ -1,5 +1,7 @@
 import knex, { TableBuilder } from "knex"
 import Model from "."
+import runWhenTrue from "../helper/runWhenTrue"
+import runWhenFalse from "../helper/runWhenFalse"
 
 export default class Status extends Model{
     #description=''
@@ -11,8 +13,9 @@ export default class Status extends Model{
         model=Status, 
         schema=(t=new TableBuilder())=>{} 
     ){
-        return db.schema
-            .createTable(
+        return runWhenFalse(
+            db.schema.hasTable(model.name),
+            ()=>db.schema.createTable(
                 model.name,
                 table=>{
                     table.increments()
@@ -25,6 +28,7 @@ export default class Status extends Model{
                     schema(table)
                 }
             )
+        )
     }
 
     constructor({ id=1, description=''}){

package/src/model/thing.js

@@ -1,5 +1,7 @@
 import knex, { TableBuilder } from "knex";
 import Model from "./index.js";
+import runWhenFalse from "../helper/runWhenFalse.js";
+import runWhenTrue from "../helper/runWhenTrue.js";
 
 
 export default class Thing extends Model{
@@ -22,17 +24,20 @@ export default class Thing extends Model{
     static makeMe(
         db=knex(),
         thing=Thing,
+        size = 255,
         schema=(t=new TableBuilder())=>{}
     ){
-        return db.schema
-            .createTable(
+        return runWhenFalse(
+            db.schema.hasTable(thing.name),
+            ()=>db.schema.createTable(
                 thing.name,
                 table=>{
                     schema(table)
 
-                    table.string(255)
+                    table.string(size)
                         .notNullable()
                 }
             )
+        )
     }
 }

package/src/model/traced.js

@@ -1,5 +1,4 @@
 import knex, { TableBuilder } from "knex"
-import Model from "./index.js"
 import Logged from "./logged.js"
 
 export default class Traced extends Logged{
@@ -10,8 +9,8 @@ export default class Traced extends Logged{
         key={},
         createdAt=new Date(),
         updatedAt=new Date()|undefined,
-        active=true}
-    ){
+        active=true
+    }){
         super({ key,createdAt })
         this.#active=active
         this.#updatedAt = updatedAt
@@ -32,22 +31,14 @@ export default class Traced extends Logged{
         model=Traced,
         schema=(t=new TableBuilder())=>{}
     ){
-        return db.schema
-            .createTable(
-                model.name,
-                table=>{
-                    schema(table)
-
-                    table.dateTime('createdAt')
-                        .notNullable()
-                        .defaultTo(db.fn.now())
-
-                    table.dateTime('updatedAt')
-                        .nullable()
-
-                    table.boolean('active')
-                        .defaultTo(true)
-                }
-            )
+        return super.makeMe(db,model,table=>{
+            schema(table)
+
+            table.dateTime('updatedAt')
+                .nullable()
+
+            table.boolean('active')
+                .defaultTo(true)
+        })
     }
 }

package/src/repository/db/context.js

@@ -27,13 +27,9 @@ export default class Context{
     static instance(database=knex()){ return new Context(database) }
 
     async terraform(models=[]){
-        const promises = models.map(async model=>{
-            const exists = await this.#db
-                .schema
-                .hasTable(model.name)
-                
-            if (!exists) await model.makeMe(this.#db)
-        })
+        const promises = models.map(async model=>model.makeMe(this.#db))
+
+        console.log('Terraforming...')
 
         await Promise.all(promises)
     }

package/src/repository/db/index.js

@@ -8,6 +8,8 @@ export default class Repository{
 
     myContext
 
+    Entity = Model
+
     static anyOrError(model,err={code:0,message:''}){
         if (!!model) return model
 
@@ -28,46 +30,48 @@ export default class Repository{
             this.myContext=()=>context.db(this.#name)
         }
 
-        this.modelInstance=(m={})=>model.build(m)
+        this.Entity = model
     }
 
     set context(value=knex()){ this.myContext=()=>value(this.#name) }
 
-    create = (model=new Model())=>
+    create = (model = new Model())=>
         this.myContext()
-        .insert({
-            ...model.key, 
-            ...model.entity
-        })
-        .then(()=>model)
+            .insert({
+                ...model.key, 
+                ...model.entity
+            })
+            .then(()=>model)
 
-    insert = (model=new Model())=>
+    insert = (model = new Model())=>
         this.myContext()
-        .insert(model.entity,Object.keys(model.key))
-        .then(ids=>model.key = ids[0])
-        .then(()=>model)
+            .insert(model.entity,Object.keys(model.key))
+            .then(ids=>{
+                model.key = ids[0]
+                return model
+            })
 
-    update = (model=new Model())=>
+    update = (model = new Model())=>
         this.myContext()
-        .where(model.key)
-        .update(model.entity)
-        .then(affected=>affected > 0)
+            .where(model.key)
+            .update(model.entity)
+            .then(affected=>affected > 0)
 
-    delete = (key={})=>
+    delete = (model = new Model())=>
         this.myContext()
-        .where(key)
-        .del()
-        .then(affected=>affected > 0)
+            .where(model.key)
+            .del()
+            .then(affected=>affected > 0)
 
-    get = (key={})=>
+    get = (model = new Model())=>
         this.myContext()
-       .where(key)
-       .first()
-       .then(model=>Repository.anyOrError(model,{code:404,message:'Not found'}))
-       .then(this.modelInstance) 
+            .where(model.key)
+            .first()
+            .then(model=>Repository.anyOrError(model,{code:404,message:'Not found'}))
+            .then(this.Entity.build) 
 
     list = ()=>
         this.myContext()
-        .select()
-        .then(result=>Repository.setOrEmpty(result,this.modelInstance))
+            .select()
+            .then(result=>Repository.setOrEmpty(result,this.Entity.build))
 }

package/src/repository/db/linked.js

@@ -12,58 +12,67 @@ export default class DbLinked {
         this.#name  = link.name
         this.myContext = () => context.db(this.#name)
         this.#linking = link
+        
     }
 
-    #insertBatch=(linkings=[new Linking()])=>
+    createBatch = (linkings=[ new Linking() ])=>
         this.myContext()
             .insert(
-                linkings.map(l => l.key())
+                linkings.map(l => (
+                    {
+                        ...l.key,
+                        ...l.entity
+                    })
+                )
             )
             .then(()=>linkings)
 
-    insert=(linked=new Linking())=>{
-        const key = linked.key()
-        
-        return this.myContext()
-            .insert(key)
-            .then(()=>key);
-    }
-
-    insertOrdinatesByAbscissa=(abscissa=new Model(),ordinates=[new Model()])=>{
+    create = (linked=new Linking())=>
+        this.myContext()
+            .insert({
+                ...linked.key,
+                ...linked.entity
+            })
+            .then(()=>linked);
+    
+
+    insertOrdinatesByAbscissa = ({ abscissa=new Model(),ordinates=[new Model()] })=>{
         const batch = ordinates
             .map(o=>this.#linking
-                .build({abscissa,o})
+                .build({abscissa,ordinate:o})
             )
 
-        return this.#insertBatch(batch);
+        return this.createBatch(batch);
     }
 
-    insertAbscissasByOrdinate=(ordinate=new Model(),abscissas=[new Model()])=>{
+    insertAbscissasByOrdinate = ({ ordinate=new Model(),abscissas=[new Model()] })=>{
         const batch = abscissas
             .map(a=>this.#linking
-                .build({a,ordinate})
+                .build({abscissa:a,ordinate})
             )
 
-        return this.#insertBatch(batch)
+        return this.createBatch(batch)
     }
 
-    delete=(linked=new Linking())=>{
-        return this.myContext()
-            .where(linked.key())
+    delete = (linked=new Linking())=>
+        this.myContext()
+            .where(linked.key)
             .del()
             .then(affected=>affected > 0)
-    }
+    
 
-    abscissasByOrdinate=(linked=new Linking())=>{
+    getAbscissasByOrdinate(linked=new Linking()){
         const Abscissa = linked.Abscissa
+        const Ordinate = linked.Ordinate
         const keys = Object.keys(linked.abscissaKey)
+        const abscissaKey = Object.keys(linked.abscissa.key)
 
-        const fields = keys.map(key=>`${this.#name}.${key}`)
-        const abscissas = keys.map(key=>`${Abscissa.name}.${key}`)
+        const fields = keys.map(key=>`${Abscissa.name}${Ordinate.name}.${key}`)
+        const abscissas = abscissaKey.map(key=>`${Abscissa.name}.${key}`)
 
         return this.myContext()
             .where(linked.ordinateKey)
-            .select(fields)
+            .select(`${Abscissa.name}.*`)
             .join(Abscissa.name,clause=>
                 fields.forEach((field,i)=>{
                     clause.on(field,abscissas[i])
@@ -74,16 +83,18 @@ export default class DbLinked {
             )
     }
 
-    ordinatesByAbscissa=(linked=new Linking())=>{
+    getOrdinatesByAbscissa(linked=new Linking()){
         const Ordinate = linked.Ordinate
+        const Abscissa = linked.Abscissa
         const keys = Object.keys(linked.ordinateKey)
+        const ordinateKeys = Object.keys(linked.ordinate.key)
 
-        const fields = keys.map(key=>`${this.#name}.${key}`)
-        const ordinates = keys.map(key=>`${Ordinate.name}.${key}`)
+        const fields = keys.map(key=>`${Abscissa.name}${Ordinate.name}.${key}`)
+        const ordinates = ordinateKeys.map(key=>`${Ordinate.name}.${key}`)
 
         return this.myContext()
             .where(linked.abscissaKey)
-            .select(fields)
+            .select(`${Ordinate.name}.*`)
             .join(Ordinate.name,clause=>
                 fields.forEach((field,i)=>{
                     clause.on(field,ordinates[i])

package/src/repository/db/loggedRepository.js

@@ -1,56 +1,58 @@
 import Logged from '../../model/logged.js';
-import Traced from '../../model/traced.js';
 import Context from './context.js';
 import Repository from './index.js';
 
-export default class TracedRepository extends Repository{
-    constructor(model=Traced,context=new Context()){
+export default class LoggedRepository extends Repository{
+    constructor(model=Logged,context=new Context()){
         super(model,context)
     }
 
-    deceased=()=>this.myContext()
-        .where({active:false})
-        .select()
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    get=(key={})=>this.myContext()
-        .where({...key,active:true})
-        .first()
-        .then(model => Repository.anyOrError(model,{code:404,message:'Not found'}))
-        .then(this.modelInstance)
-
-    before=(date=new Date())=>this.myContext()
-        .where('createdAt','<',date.toISOString())
-        .select()
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    after=(date=new Date())=>this.myContext()
-        .where('createdAt','>',date.toISOString())
-        .select()
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    list=()=>this.myContext()
-        .select()
-        .orderBy('createdAt','updatedAt')
-        .where({active:true})
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    update=(model=new Logged())=>
+    get = (logged = new Logged())=>
         this.myContext()
-        .where(model.key)
-        .update({
-            ...model.entity,
-            updatedAt:new Date().toISOString()
-        })
-        .then(affected => affected > 0)
-
-    delete=(key={})=>
+            .where({...logged.key})
+            .first()
+            .then(model => Repository.anyOrError(model,{code:404,message:'Not found'}))
+            .then(this.Entity.build)
+
+    before = (date = new Date(), order = 'asc')=>
+        this.myContext()
+            .where('createdAt','<',date.toISOString())
+            .select()
+            .orderBy('createdAt',order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    after = (date = new Date(), order = 'asc')=>
+        this.myContext()
+            .where('createdAt','>',date.toISOString())
+            .select()
+            .orderBy('createdAt',order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    list = (order='asc')=>
         this.myContext()
-        .where(key)
-        .update({
-            active:false,
-            updatedAt:new Date().toISOString()
-        })
-        .then(affected => affected > 0)
+            .select()
+            .orderBy('createdAt',order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    insert = (logged = new Logged())=>
+        this.myContext()
+            .insert({
+                ...logged.entity,
+                createdAt:new Date().toISOString()  
+            },Object.keys(logged.key))
+            .then(ids => logged.key = ids[0])
+            .then(() => logged)
+
+    create = (logged = new Logged())=>
+        this.myContext()
+            .insert({
+                ...logged.entity,
+                createdAt:new Date().toISOString() 
+            })
+            .then(() => logged)
+
+    update = ()=> Promise.reject(new Error('Cannot update a logged object'))
+
+    delete = ()=> Promise.reject(new Error('Cannot delete a logged object'))
     
 }

package/src/repository/db/thingRepository.js

@@ -3,12 +3,13 @@ import Context from "./context.js";
 import Repository from "./index.js";
 
 export default class ThingRepository extends Repository{
-    constructor(context=new Context()){
-        super(model=Thing,context)
+    constructor(model = Thing,context=new Context()){
+        super(model,context)
     }
 
-    getByName=(name='')=>this.myContext()
-        .where({name})
-        .select()
-        .then(result=>Repository.setOrEmpty(result,this.modelInstance))
+    getByName=(name='')=>
+        this.myContext()
+            .where({name})
+            .select()
+            .then(result=>Repository.setOrEmpty(result,this.Entity.build))
 }

package/src/repository/db/tracedRepository.js

@@ -7,33 +7,83 @@ export default class TracedRepository extends Repository{
         super(model,context)
     }
 
-    before=(date=new Date())=>this.myContext()
-        .where('createdAt','<',date.toISOString())
-        .select()
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    after=(date=new Date())=>this.myContext()
-        .where('createdAt','>',date.toISOString())
-        .select()
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    list=()=>this.myContext()
-        .select()
-        .orderBy('createdAt')
-        .then(result => Repository.setOrEmpty(result,this.modelInstance))
-
-    last=()=>this.myContext()
-        .first()
-        .orderBy('createdBy',order="desc")
-        .then(result => Repository.anyOrError(result,{code:400,message:'Not found'}))
-
-    first=()=>this.myContext()
-        .first()
-        .orderBy('createdBy',order="asc")
-        .then(result => Repository.anyOrError(result,{code:400,message:'Not found'}))
-
-    create=(traced=new Traced())=>this.myContext()
-        .insert({ ...traced.entity, createdAt:new Date().toISOString() }, Object.keys(model.key))
-        .then(ids=>model.key = ids[0])
-        .then(()=> model)
+    deceased = (order = 'asc')=>
+        this.myContext()
+            .where({active:false})
+            .select()
+            .orderBy(['createdAt','updatedAt'],order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    before = (date = new Date(), order = 'asc')=>
+        this.myContext()
+            .where('createdAt','<',date.toISOString())
+            .where({active:true})
+            .select()
+            .orderBy(['createdAt','updatedAt'],order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    after = (date=new Date(), order = 'asc')=>
+        this.myContext()
+            .where('createdAt','>',date.toISOString())
+            .where({active:true})
+            .select()
+            .orderBy(['createdAt','updatedAt'],order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    list = (order = 'asc')=>
+        this.myContext()
+            .where({active:true})
+            .select()
+            .orderBy(['createdAt','updatedAt'],order)
+            .then(result => Repository.setOrEmpty(result,this.Entity.build))
+
+    last = ()=>
+        this.myContext()
+            .where({active:true})
+            .first()
+            .orderBy('createdAt',"desc")
+            .then(result => Repository.anyOrError(result,{code:404,message:'Not found'}))
+
+    first = ()=>
+        this.myContext()
+            .where({active:true})
+            .first()
+            .orderBy('createdAt',"asc")
+            .then(result => Repository.anyOrError(result,{code:404,message:'Not found'}))
+
+    insert = (traced=new Traced())=>
+        this.myContext()
+            .insert({ 
+                ...traced.entity, 
+                createdAt:new Date().toISOString() 
+            }, Object.keys(traced.key))
+            .then(ids=>traced.key = ids[0])
+            .then(()=> traced)
+
+    create = (traced=new Traced())=>
+        this.myContext()
+            .insert({
+                    ...traced.key, 
+                    ...traced.entity, 
+                    createdAt:new Date().toISOString() 
+            })
+            .then(()=> traced)
+
+    update = (traced=new Traced())=>
+        this.myContext()
+            .where(traced.key)
+            .update({
+                ...traced.entity,
+                updatedAt:new Date().toISOString()
+            })
+            .then(affected=>affected > 0)
+
+    delete = (traced=new Traced())=>
+        this.myContext()
+            .where(traced.key)
+            .update({
+                active:false,
+                updatedAt:new Date().toISOString()
+            })
+            .then(affected=>affected > 0)
 }