@keltoi/hydra 1.1.0 → 1.1.3

package/index.js

@@ -1 +1 @@
-"use strict";var t=require("knex"),e=require("axios");class Model{#t;constructor(t={}){this.#t=t}get key(){return this.#t}set key(t={}){this.#t=t}get entity(){return{}}}class Logged extends Model{#e=new Date;#n=void 0|new Date;#s=!0;constructor({key:t={},createdAt:e=new Date,updatedAt:n=void 0|new Date,active:s=!0}){super(t),this.#s=s,this.#n=n,this.#e=e}get createdAt(){return this.#e}set createdAt(t=new Date){this.createdAt=t}get updatedAt(){return this.#n}set updatedAt(t=new Date){this.#n=t}get active(){return this.#s}set active(t=!0){this.#s=t}static makeMe(e=t(),n=Model,s=(e=new t.TableBuilder)=>{}){return e.schema.createTable(n.name,(t=>{s(t),t.dateTime("createdAt").notNullable().defaultTo(e.fn.now()),t.dateTime("updatedAt").nullable(),t.boolean("active").defaultTo(!0)}))}}class Thing extends Model{#o;constructor({key:t={},name:e=""}){super(t),this.#o=e}get name(){return this.#o}set name(t=""){this.#o=t}get entity(){return{name:this.#o}}static makeMe(e=t(),n=Thing,s=(e=new t.TableBuilder)=>{}){return e.schema.createTable(n.name,(t=>{s(t),t.string(255).notNullable()}))}}let n=class Context{#r;constructor(e=t()){this.#r=e}get db(){return this.#r}unitOfWork(...t){return this.#r.transaction().then((e=>(t.forEach((t=>t.context=e)),{done:()=>e.commit().then((()=>t.forEach((t=>t.resetContext())))),rollback:()=>e.rollback().then((()=>t.forEach((t=>t.resetContext()))))})))}static instance(e=t()){return new Context(e)}async terraform(t=[]){const e=t.map((async t=>{await this.#r.schema.hasTable(t.name)||await t.makeMe(this.#r)}));await Promise.all(e)}},s=class Repository{#o="";myContext;static anyOrError(t,e={code:0,message:""}){if(t)return t;throw e}static setOrEmpty(t=[],e=t=>t){return t.length?t.map(e):[]}constructor(t=Model,e=new n){this.#o=t.name,this.myContext=()=>e.db(this.#o),this.resetContext=()=>{this.myContext=()=>e.db(this.#o)},this.modelInstance=(e={})=>new t(e)}set context(e=t()){this.myContext=()=>e(this.#o)}insert=(t=new Model)=>this.myContext().insert(t.entity,Object.keys(t.key)).then((e=>t.key=e[0])).then((()=>t));update=(t=new Model)=>this.myContext().where(t.key).update(t.entity).then((t=>t>0));delete=(t={})=>this.myContext().where(t).del().then((t=>t>0));get=(t={})=>this.myContext().where(t).first().then(Repository.anyOrError).then(this.modelInstance);list=()=>this.myContext().select().then((t=>Repository.setOrEmpty(t,this.modelInstance)))};class Context{#a;constructor(t=e.create({})){this.#a=t}get http(){return this.#a}}class Repository{#i;constructor(t=Model,e=new Context){this.#i=e,this.modelInstance=(e={})=>new t(e)}static queryString(t={}){return"?"+Object.entries(t).map((([t,e])=>`${t}=${e}`)).join("&")}get context(){return this.#i}}exports.ApiContext=Context,exports.ApiRepository=Repository,exports.ApiRestRepository=class RestRepository extends Repository{constructor(t=Model,e=new Context){super(t,e)}#h=(t="",e=void 0|{})=>this.context.http.get(e?`${t}${Repository.queryString(e)}`:t);get=(t="",e=void 0|{})=>this.#h(t,e).then((t=>this.modelInstance(t)));list=(t="",e=void 0|{})=>this.#h(t,e).then(((t=[])=>t.map((t=>this.modelInstance(t)))));create=(t="",e=new Model)=>this.context.http.post(t,e.entity);update=(t="",e=new Model)=>this.context.http.put(t,e.entity);change=(t="",e=new Model)=>this.context.http.patch(t,e.entity);delete=(t,e=new Model)=>this.context.http.delete(`/${t}`)},exports.DbContext=n,exports.DbLoggedRepository=class LoggedRepository extends s{constructor(t=Logged,e=new n){super(t,e)}deceased=()=>this.myContext().where({active:!1}).select().then((t=>t.map(this.modelInstance)));get=(t={})=>this.myContext().where({...t,active:!0}).first().then(this.modelInstance);before=(t=new Date)=>this.myContext().where("createdAt","<",t.toISOString()).select().then((t=>t.map(this.modelInstance)));after=(t=new Date)=>this.myContext().where("createdAt",">",t.toISOString()).select().then((t=>t.map(this.modelInstance)));list=()=>this.myContext().select().orderBy("createdAt","updatedAt").where({active:!0}).then((t=>t.map(this.modelInstance)));update=(t=new Logged)=>this.myContext().where(t.key).update({...t.entity,updatedAt:new Date}).then((t=>t>0));delete=(t={})=>this.myContext().where(t).update({updatedAt:(new Date).toISOString(),active:!1}).then((t=>t>0))},exports.DbRepository=s,exports.DbThingRepository=class ThingRepository extends s{constructor(t=new n){super(model=Thing,t)}getByName=(t="")=>this.myContext().where({name:t}).select().then((t=>this.modelInstance(t)))},exports.Logged=Logged,exports.Model=Model,exports.Thing=Thing;
+"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;#n=void 0|new Date;#s=!0;constructor({key:e={},createdAt:t=new Date,updatedAt:n=void 0|new Date,active:s=!0}){super(e),this.#s=s,this.#n=n,this.#t=t}get createdAt(){return this.#t}set createdAt(e=new Date){this.createdAt=e}get updatedAt(){return this.#n}set updatedAt(e=new Date){this.#n=e}get active(){return this.#s}set active(e=!0){this.#s=e}static makeMe(t=e(),n=Model,s=(t=new e.TableBuilder)=>{}){return t.schema.createTable(n.name,(e=>{s(e),e.dateTime("createdAt").notNullable().defaultTo(t.fn.now()),e.dateTime("updatedAt").nullable(),e.boolean("active").defaultTo(!0)}))}}class Linking{#i=new Model;#a=new Model;#o=Model;#r=Model;get Abscissa(){return this.#o}get Ordinate(){return this.#r}static build=({abscissa:e=new Model,ordinate:t=new Model})=>new Linking(Model,Model,{abscissa:e,ordinate:t});constructor(e=Model,t=Model,{abscissa:n=e.build(),ordinate:s=t.build()}){this.#o=e,this.#r=t,this.#i=n,this.#a=s}static makeMe(t=e(),n=Model,s=Model,i=(t=new e.TableBuilder)=>{}){return t.schema.createTable(`${n.name}${s.name}`,(e=>{i(e)}))}get abscissaKey(){return{idAbscissa:this.#i.key.id}}get ordinateKey(){return{idOrdinate:this.#a.key.id}}get key(){return{...this.abscissaKey,...this.ordinateKey}}get abscissa(){return this.#i}set abscissa(e=new Model){this.#i=e}get ordinate(){return this.#a}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(),n=Thing,s=(t=new e.TableBuilder)=>{}){return t.schema.createTable(n.name,(e=>{s(e),e.string(255).notNullable()}))}}let n=class Context{#h;constructor(t=e()){this.#h=t}get db(){return this.#h}unitOfWork(...e){return this.#h.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.#h.schema.hasTable(e.name)||await e.makeMe(this.#h)}));await Promise.all(t)}},s=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 n){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)}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{#c;constructor(e=t.create({})){this.#c=e}get http(){return this.#c}}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=n,exports.DbLinked=class DbLinked{#u;#d="";myContext;constructor(e=Linking,t=new n){this.#d=e.name,this.myContext=()=>t.db(this.#d),this.#u=e}#y=(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 n=t.map((t=>this.#u.build({abscissa:e,o:t})));return this.#y(n)};insertAbscissasByOrdinate=(e=new Model,t=[new Model])=>{const n=t.map((t=>this.#u.build({a:t,ordinate:e})));return this.#y(n)};delete=(e=new Linking)=>this.myContext().where(e.key()).del().then((e=>e>0));abscissasByOrdinate=(e=new Linking)=>{const t=e.Abscissa,n=Object.keys(e.abscissaKey),s=n.map((e=>`${this.#d}.${e}`)),i=n.map((e=>`${t.name}.${e}`));return this.myContext().where(e.ordinateKey).select(s).join(t.name,(e=>s.forEach(((t,n)=>{e.on(t,i[n])})))).then((e=>e.map((e=>t.build(e)))))};ordinatesByAbscissa=(e=new Linking)=>{const t=e.Ordinate,n=Object.keys(e.ordinateKey),s=n.map((e=>`${this.#d}.${e}`)),i=n.map((e=>`${t.name}.${e}`));return this.myContext().where(e.abscissaKey).select(s).join(t.name,(e=>s.forEach(((t,n)=>{e.on(t,i[n])})))).then((e=>e.map((e=>t.build(e)))))}},exports.DbLoggedRepository=class LoggedRepository extends s{constructor(e=Logged,t=new n){super(e,t)}deceased=()=>this.myContext().where({active:!1}).select().then((e=>e.map(this.modelInstance)));get=(e={})=>this.myContext().where({...e,active:!0}).first().then(this.modelInstance);before=(e=new Date)=>this.myContext().where("createdAt","<",e.toISOString()).select().then((e=>e.map(this.modelInstance)));after=(e=new Date)=>this.myContext().where("createdAt",">",e.toISOString()).select().then((e=>e.map(this.modelInstance)));list=()=>this.myContext().select().orderBy("createdAt","updatedAt").where({active:!0}).then((e=>e.map(this.modelInstance)));update=(e=new Logged)=>this.myContext().where(e.key).update({...e.entity,updatedAt:new Date}).then((e=>e>0));delete=(e={})=>this.myContext().where(e).update({updatedAt:(new Date).toISOString(),active:!1}).then((e=>e>0))},exports.DbRepository=s,exports.DbThingRepository=class ThingRepository extends s{constructor(e=new n){super(model=Thing,e)}getByName=(e="")=>this.myContext().where({name:e}).select().then((e=>this.modelInstance(e)))},exports.Linking=Linking,exports.Logged=Logged,exports.Model=Model,exports.Thing=Thing;

package/package.json

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

package/src/index.js

@@ -1,8 +1,10 @@
 import Logged from './model/logged.js'
 import Model from './model/index.js'
+import Linking from './model/linking.js'
 import Thing from './model/thing.js'
 import DbContext from './repository/db/context.js'
 import DbRepository from './repository/db/index.js'
+import DbLinked from './repository/db/linked.js'
 import DbLoggedRepository  from './repository/db/loggedRepository.js'
 import DbThingRepository from './repository/db/thingRepository.js'
 import ApiContext from './repository/api/context.js'
@@ -13,8 +15,10 @@ export {
     Model,
     Thing,
     Logged,
+    Linking,
     DbContext,
     DbRepository,
+    DbLinked,
     DbLoggedRepository,
     DbThingRepository,
     ApiContext,

package/src/model/index.js

@@ -1,13 +1,14 @@
 export default class Model{
     #key
+
     constructor(key={}){
         this.#key = key
     }
 
-    get key(){return this.#key }
-    set key(value={}){this.#key=value}    
+    get key(){ return this.#key }
+    set key(value={}){ this.#key=value }    
 
-    get entity(){return {}}
+    get entity(){ return {} }
 
     static build(key={}){
         return new Model(key)

package/src/model/linking.js

@@ -0,0 +1,75 @@
+import knex, { TableBuilder } from "knex"
+import Model from "./index"
+
+export default class Linking{
+    #abscissa=new Model()
+    #ordinate=new Model()
+    #AbscissaModel=Model
+    #OrdinateModel=Model
+
+
+    get Abscissa(){
+        return this.#AbscissaModel
+    }
+
+    get Ordinate(){
+        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()
+        })
+    {
+        this.#AbscissaModel = AbscissaModel
+        this.#OrdinateModel = OrdinateModel
+
+        this.#abscissa = abscissa
+        this.#ordinate = ordinate
+    }
+
+    static makeMe(
+        db=knex(),
+        abscissa=Model,
+        ordinate=Model,
+        schema=(t=new knex.TableBuilder())=>{}
+    ){
+        return db.schema
+            .createTable(
+                `${abscissa.name}${ordinate.name}`,
+                table=>{
+                    schema(table)
+                }
+            )
+    }
+
+    get abscissaKey(){
+        return { idAbscissa: this.#abscissa.key['id'] }
+    }
+
+    get ordinateKey(){
+        return { idOrdinate: this.#ordinate.key['id'] }
+    }
+
+    get key(){
+        return {
+            ...this.abscissaKey,
+            ...this.ordinateKey
+        }
+    }
+
+    get abscissa(){ return this.#abscissa }
+    set abscissa(value = new Model()){ this.#abscissa = value }
+
+    get ordinate(){ return this.#ordinate }
+    set ordinate(value = new Model()){ this.ordinate = value }
+
+}

package/src/model/logged.js

@@ -6,29 +6,48 @@ export default class Logged extends Model{
     #updatedAt=new Date()|undefined
     #active=true
 
-    constructor({key={},createdAt=new Date(),updatedAt=new Date()|undefined,active=true}){
+    constructor({
+        key={},
+        createdAt=new Date(),
+        updatedAt=new Date()|undefined,
+        active=true}
+    ){
         super(key)
         this.#active=active
         this.#updatedAt = updatedAt
         this.#createdAt = createdAt
     }
 
-    get createdAt(){return this.#createdAt}
-    set createdAt(value = new Date()){this.createdAt = value}
+    get createdAt(){ return this.#createdAt }
+    set createdAt(value = new Date()){ this.createdAt = value }
 
-    get updatedAt(){return this.#updatedAt}
-    set updatedAt(value = new Date()){this.#updatedAt = value}
+    get updatedAt(){ return this.#updatedAt }
+    set updatedAt(value = new Date()){ this.#updatedAt = value }
 
-    get active(){return this.#active}
-    set active(value = true){this.#active = value}
+    get active(){ return this.#active }
+    set active(value = true){ this.#active = value }
 
-    static makeMe(db=knex(),model=Model,schema=(t=new knex.TableBuilder())=>{}){
-        return db.schema.createTable(model.name,table=>{
-            schema(table)
+    static makeMe(
+        db=knex(),
+        model=Model,
+        schema=(t=new knex.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)
-        })
+                    table.dateTime('createdAt')
+                        .notNullable()
+                        .defaultTo(db.fn.now())
+
+                    table.dateTime('updatedAt')
+                        .nullable()
+
+                    table.boolean('active')
+                        .defaultTo(true)
+                }
+            )
     }
 }

package/src/model/thing.js

@@ -4,23 +4,35 @@ import Model from "./index.js";
 
 export default class Thing extends Model{
     #name
-    constructor({key={},name=''}){
+    constructor({
+        key={},
+        name=''
+    }){
         super(key)
         this.#name = name
     }
 
-    get name(){return this.#name}
-    set name(value=''){this.#name=value}    
+    get name(){ return this.#name }
+    set name(value=''){ this.#name=value }    
 
     get entity(){
-        return {name:this.#name}
+        return { name:this.#name }
     }
 
-    static makeMe(db=knex(),thing=Thing,schema=(t=new knex.TableBuilder())=>{}){
-        return db.schema.createTable(thing.name,table=>{
-            schema(table)
+    static makeMe(
+        db=knex(),
+        thing=Thing,
+        schema=(t=new knex.TableBuilder())=>{}
+    ){
+        return db.schema
+            .createTable(
+                thing.name,
+                table=>{
+                    schema(table)
 
-            table.string(255).notNullable()
-        })
+                    table.string(255)
+                        .notNullable()
+                }
+            )
     }
 }

package/src/repository/api/context.js

@@ -2,9 +2,10 @@ import axios from "axios"
 
 export default class Context{
     #http
+
     constructor(config=axios.create({})){
         this.#http = config
     }
 
-    get http(){return this.#http}
+    get http(){ return this.#http }
 }

package/src/repository/api/index.js

@@ -3,14 +3,17 @@ import Context from "./context.js"
 
 export default class Repository{
     #context
+
     constructor(model=Model,context=new Context()){
         this.#context = context
         this.modelInstance=(m={})=>new model(m)
     }
 
     static queryString(param={}){
-        return '?' + Object.entries(param).map(([k,v])=>`${k}=${v}`).join('&')
+        return '?' + Object.entries(param)
+            .map(([k,v])=>`${k}=${v}`)
+            .join('&')
     }
 
-    get context(){return this.#context}
+    get context(){ return this.#context }
 }

package/src/repository/api/restRepository.js

@@ -12,15 +12,25 @@ export default class RestRepository extends Repository{
         .http
         .get(!! query ? `${route}${Repository.queryString(query)}` : route)
 
-    get=(route='',query={}|undefined)=>this.#httpGet(route,query).then(value=>this.modelInstance(value))
+    get=(route='',query={}|undefined)=>this.#httpGet(route,query)
+        .then(value=>this.modelInstance(value))
 
-    list=(route='',query={}|undefined)=>this.#httpGet(route,query).then((values=[])=>values.map(value=>this.modelInstance(value)))
+    list=(route='',query={}|undefined)=>this.#httpGet(route,query)
+        .then((values=[])=>values.map(value=>this.modelInstance(value)))
 
-    create=(route='',model=new Model())=>this.context.http.post(route,model.entity)
+    create=(route='',model=new Model())=>this.context
+        .http
+        .post(route,model.entity)
 
-    update=(route='',model=new Model())=>this.context.http.put(route,model.entity)
+    update=(route='',model=new Model())=>this.context
+        .http
+        .put(route,model.entity)
 
-    change=(route='',model=new Model())=>this.context.http.patch(route,model.entity)
+    change=(route='',model=new Model())=>this.context
+        .http
+        .patch(route,model.entity)
 
-    delete=(id,model=new Model())=>this.context.http.delete(`/${id}`)
+    delete=(id,model=new Model())=>this.context
+        .http
+        .delete(`/${id}`)
 }

package/src/repository/db/context.js

@@ -13,18 +13,25 @@ export default class Context{
         return this.#db.transaction().then(trx=>{
             repositories.forEach(repo=>repo.context = trx)
 
+            const clean =()=>repositories.forEach(repo=>
+                repo.resetContext()
+            )
+
             return {
-                done:()=>trx.commit().then(()=>repositories.forEach(repo=>repo.resetContext())),
-                rollback:()=>trx.rollback().then(()=>repositories.forEach(repo=>repo.resetContext()))
+                done:()=>trx.commit().then(clean),
+                rollback:()=>trx.rollback().then(clean)
             }
         })
     }
 
-    static instance(database=knex()){return new Context(database)}
+    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)
+            const exists = await this.#db
+                .schema
+                .hasTable(model.name)
+                
             if (!exists) await model.makeMe(this.#db)
         })
 

package/src/repository/db/index.js

@@ -21,14 +21,17 @@ export default class Repository{
     constructor(model=Model,context=new Context())
     {
         this.#name = model.name
+
         this.myContext=()=>context.db(this.#name)
+
         this.resetContext=()=>{
             this.myContext=()=>context.db(this.#name)
         }
+
         this.modelInstance=(m={})=>model.build(m)
     }
 
-    set context(value=knex()){ this.myContext=()=>value(this.#name)}
+    set context(value=knex()){ this.myContext=()=>value(this.#name) }
 
     insert=(model=new Model())=>
         this.myContext()

package/src/repository/db/linked.js

@@ -0,0 +1,97 @@
+
+import Model from "../../model/index";
+import Linking from "../../model/linking";
+import Context from "./context";
+
+export default class DbLinked {
+    #linking
+    #name=''
+    myContext
+
+    constructor(link=Linking,context=new Context){
+        this.#name  = link.name
+        this.myContext = () => context.db(this.#name)
+        this.#linking = link
+    }
+
+    #insertBatch=(linkings=[new Linking()])=>
+        this.myContext()
+            .insert(
+                linkings.map(l => l.key())
+            )
+            .then(()=>linkings)
+
+    insert=(linked=new Linking())=>{
+        const key = linked.key()
+        
+        return this.myContext()
+            .insert(key)
+            .then(()=>key);
+    }
+
+    insertOrdinatesByAbscissa=(abscissa=new Model(),ordinates=[new Model()])=>{
+        const batch = ordinates
+            .map(o=>this.#linking
+                .build({abscissa,o})
+            )
+
+        return this.#insertBatch(batch);
+    }
+
+    insertAbscissasByOrdinate=(ordinate=new Model(),abscissas=[new Model()])=>{
+        const batch = abscissas
+            .map(a=>this.#linking
+                .build({a,ordinate})
+            )
+
+        return this.#insertBatch(batch)
+    }
+
+    delete=(linked=new Linking())=>{
+        return this.myContext()
+            .where(linked.key())
+            .del()
+            .then(affected=>affected > 0)
+    }
+
+    abscissasByOrdinate=(linked=new Linking())=>{
+        const Abscissa = linked.Abscissa
+        const keys = Object.keys(linked.abscissaKey)
+
+        const fields = keys.map(key=>`${this.#name}.${key}`)
+        const abscissas = keys.map(key=>`${Abscissa.name}.${key}`)
+
+        return this.myContext()
+            .where(linked.ordinateKey)
+            .select(fields)
+            .join(Abscissa.name,clause=>
+                fields.forEach((field,i)=>{
+                    clause.on(field,abscissas[i])
+                })
+            )
+            .then(list=>
+                list.map(abscissa=>Abscissa.build(abscissa))
+            )
+    }
+
+    ordinatesByAbscissa=(linked=new Linking())=>{
+        const Ordinate = linked.Ordinate
+        const keys = Object.keys(linked.ordinateKey)
+
+        const fields = keys.map(key=>`${this.#name}.${key}`)
+        const ordinates = keys.map(key=>`${Ordinate.name}.${key}`)
+
+        return this.myContext()
+            .where(linked.abscissaKey)
+            .select(fields)
+            .join(Ordinate.name,clause=>
+                fields.forEach((field,i)=>{
+                    clause.on(field,ordinates[i])
+                })
+            )
+            .then(list=>
+                list.map(ordinate=>Ordinate.build(ordinate))
+            )
+    }
+
+}