@keltoi/hydra 1.3.0 → 2.0.0

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@keltoi/hydra",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Boilerplate to start your API from zero using Repository Pattern",
   "main": "index.js",
+  "module": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "type": "module",
   "scripts": {
     "test": "npm run build & npm link",
     "build": "rollup -c"
@@ -25,6 +30,10 @@
     "@rollup/plugin-terser": "^0.4.4",
     "axios": "^1.7.7",
     "knex": "^3.1.0",
-    "rollup": "^4.24.4"
+    "rollup": "^4.40.2"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-json": "^6.1.0"
   }
 }

package/.github/workflows/npm-publish.yml

@@ -1,33 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.KELTOI_GITPUB}}

package/rollup.config.mjs

@@ -1,17 +0,0 @@
-import terser from '@rollup/plugin-terser';
-
-export default {
-    input:'src/index.js',
-    plugins:[
-        terser({
-            keep_classnames:true,
-            keep_fnames:true
-        })
-    ],
-    output:[
-        {
-            file:'index.js',
-            format:'cjs'
-        }
-    ]
-}

package/src/handler/index.js

@@ -1,18 +0,0 @@
-import Result from "../model/result";
-import Context from "../repository/db/context";
-
-export default class Handler {
-    #context
-    constructor({ context = new Context }) {
-        this.#context = context;
-    }
-
-    get context(){
-        return this.#context
-    }
-
-    handle(){}
-    handleError({ code, message }) {
-        return Promise.reject(new Result({ code, message }));
-    }
-}

package/src/helper/runWhenFalse.js

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

package/src/helper/runWhenTrue.js

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

package/src/index.js

@@ -1,41 +0,0 @@
-import Result from './model/result.js'
-import Traced from './model/traced.js'
-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 DbTracedRepository  from './repository/db/tracedRepository.js'
-import DbThingRepository from './repository/db/thingRepository.js'
-import ApiContext from './repository/api/context.js'
-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 {
-    Result,
-    Model,
-    Thing,
-    Traced,
-    Logged,
-    Linking,
-    DbContext,
-    DbRepository,
-    DbLinked,
-    DbTracedRepository,
-    DbLoggedRepository,
-    DbThingRepository,
-    ApiContext,
-    ApiRepository,
-    ApiRestRepository,
-    Service,
-    Handler,
-    runWhenTrue,
-    runWhenFalse
-}

package/src/model/index.js

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

package/src/model/linking.js

@@ -1,85 +0,0 @@
-import knex, { TableBuilder } from "knex"
-import Model from "./index"
-import runWhenFalse from "../helper/runWhenFalse"
-
-export default class Linking{
-    #abscissa=new Model()
-    #ordinate=new Model()
-    #AbscissaModel=Model
-    #OrdinateModel=Model
-
-
-    get Abscissa(){
-        return this.#AbscissaModel
-    }
-
-    get Ordinate(){
-        return this.#OrdinateModel
-    }
-
-    constructor(
-        AbscissaModel=Model,
-        OrdinateModel=Model,
-        {
-            abscissa = new AbscissaModel(),
-            ordinate = new OrdinateModel()
-        })
-    {
-        this.#AbscissaModel = AbscissaModel
-        this.#OrdinateModel = OrdinateModel
-
-        this.#abscissa = abscissa
-        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 TableBuilder())=>{}
-    ){
-        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 }
-    }
-
-    get ordinateKey(){
-        return { idOrdinate: this.#ordinate.key }
-    }
-
-    get key(){
-        return {
-            ...this.abscissaKey,
-            ...this.ordinateKey
-        }
-    }
-
-    get entity(){}
-
-    get abscissa(){ return this.#abscissa }
-    set abscissa(value = this.Abscissa.build()){ this.#abscissa = value }
-
-    get ordinate(){ return this.#ordinate }
-    set ordinate(value = this.Ordinate.build()){ this.ordinate = value }
-
-}

package/src/model/logged.js

@@ -1,38 +0,0 @@
-import knex, { TableBuilder } from "knex"
-import Model from "./index.js"
-import runWhenFalse from "../helper/runWhenFalse.js"
-
-export default class Logged extends Model{
-    #createdAt=new Date()
-
-    constructor({
-        key={},
-        createdAt=new Date()
-    }){
-        super(key)
-        this.#createdAt = createdAt
-    } 
-
-    get createdAt(){ return this.#createdAt }
-    set createdAt(value = new Date()){ this.createdAt = value }
-
-    static makeMe(
-        db=knex(),
-        model=Logged,
-        schema=(t=new TableBuilder())=>{}
-    ){
-        return runWhenFalse(
-            db.schema.hasTable(model.name),
-            ()=>db.schema.createTable(
-                model.name,
-                table=>{
-                    schema(table)
-
-                    table.dateTime('createdAt')
-                        .notNullable()
-                        .defaultTo(db.fn.now())
-                }
-            )
-        )
-    }
-}

package/src/model/result.js

@@ -1,39 +0,0 @@
-class Result {
-    #code
-    #message
-    #data
-
-    constructor({ code=0, message='', data={} }) {
-        this.#code = code
-        this.#message = message
-        this.#data = data
-    }
-
-    get error() {
-        return {
-            code: this.code,
-            message: this.message
-        }
-    }
-
-    get ok() {
-        return {
-            code: this.code,
-            data: this.data
-        }
-    }
-
-    sendError(res) { 
-        res
-            .status(this.#code)
-            .send(this.#message) 
-    }
-
-    sendOk(res) { 
-        res
-            .status(this.#code)
-            .json(this.#data)
-    }
-}
-
-export default Result

package/src/model/status.js

@@ -1,46 +0,0 @@
-import knex, { TableBuilder } from "knex"
-import Model from "."
-import runWhenFalse from "../helper/runWhenFalse"
-
-export default class Status extends Model{
-    #description=''
-
-    static build=({ id=1,description='' })=>new Status({id,description})
-
-    static makeMe( 
-        db=knex(), 
-        model=Status, 
-        schema=(t=new TableBuilder())=>{} 
-    ){
-        return runWhenFalse(
-            db.schema.hasTable(model.name),
-            ()=>db.schema.createTable(
-                model.name,
-                table=>{
-                    table.increments()
-
-                    table
-                        .string('status',50)
-                        .notNullable()
-                        .unique()
-
-                    schema(table)
-                }
-            )
-        )
-    }
-
-    constructor({ id=1, description=''}){
-        super({id})
-        this.#description = description
-    }
-
-    get description(){ return this.#description }
-    set description( value='' ){ this.#description = value }
-
-    get entity(){
-        return {
-            description:this.#description
-        }
-    }
-}

package/src/model/thing.js

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

package/src/model/traced.js

@@ -1,44 +0,0 @@
-import knex, { TableBuilder } from "knex"
-import Logged from "./logged.js"
-
-export default class Traced extends Logged{
-    #updatedAt=new Date()|undefined
-    #active=true
-
-    constructor({
-        key={},
-        createdAt=new Date(),
-        updatedAt=new Date()|undefined,
-        active=true
-    }){
-        super({ key,createdAt })
-        this.#active=active
-        this.#updatedAt = updatedAt
-    }
-
-    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 }
-
-    tickUpdateNow(){
-        this.#updatedAt = new Date()
-    }
-
-    static makeMe(
-        db=knex(),
-        model=Traced,
-        schema=(t=new TableBuilder())=>{}
-    ){
-        return super.makeMe(db,model,table=>{
-            schema(table)
-
-            table.dateTime('updatedAt')
-                .nullable()
-
-            table.boolean('active')
-                .defaultTo(true)
-        })
-    }
-}

package/src/repository/api/context.js

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

package/src/repository/api/index.js

@@ -1,19 +0,0 @@
-import Model  from "../../model/index.js"
-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('&')
-    }
-
-    get context(){ return this.#context }
-}

package/src/repository/api/restRepository.js

@@ -1,36 +0,0 @@
-import Model from "../../model/index.js"
-import Context from "./context.js"
-import Repository from "./index.js"
-
-
-export default class RestRepository extends Repository{
-    constructor(model=Model,context=new Context()){
-        super(model,context)
-    }
-
-    #httpGet=(route='',query={}|undefined)=>this.context
-        .http
-        .get(!! query ? `${route}${Repository.queryString(query)}` : route)
-
-    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)))
-
-    create=(route='',model=new Model())=>this.context
-        .http
-        .post(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)
-
-    delete=(id,model=new Model())=>this.context
-        .http
-        .delete(`/${id}`)
-}

package/src/repository/db/context.js

@@ -1,34 +0,0 @@
-import knex from "knex"
-
-export default class Context{
-    #db
-
-    constructor(database=knex()){
-        this.#db= database
-    }
-
-    get db(){return this.#db}
-
-    unitOfWork(...repositories){
-        return this.#db.transaction().then(trx=>{
-            repositories.forEach(repo=>repo.context = trx)
-
-            const clean =()=>repositories.forEach(repo=>
-                repo.resetContext()
-            )
-
-            return {
-                done:()=>trx.commit().then(clean),
-                rollback:()=>trx.rollback().then(clean)
-            }
-        })
-    }
-
-    static instance(database=knex()){ return new Context(database) }
-
-    async terraform(models=[]){
-        const promises = models.map(async model=>model.makeMe(this.#db))
-
-        await Promise.all(promises)
-    }
-}

package/src/repository/db/index.js

@@ -1,82 +0,0 @@
-import knex from "knex";
-import Model from "../../model/index.js";
-import Context from "./context.js";
-import Result from "../../model/result.js";
-
-
-export default class Repository{
-    #name='';
-
-    myContext
-
-    Entity = Model
-
-    static anyOrError(model,err={code:0,message:''}){
-        if (!!model) return model
-
-        throw new Result(err);
-    }
-
-    static setOrEmpty(array=[],modeling=(e)=>e){
-        return array.length ? array.map(modeling) : []
-    }
-
-    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.Entity = model
-    }
-
-    set context(value=knex()){ this.myContext=()=>value(this.#name) }
-
-    create = (model = new Model())=>
-        this.myContext()
-            .insert({
-                ...model.key, 
-                ...model.entity
-            })
-            .then(()=>model)
-
-    insert = (model = new Model())=>
-        this.myContext()
-            .insert(model.entity,Object.keys(model.key))
-            .then(ids=>{
-                model.key = ids[0]
-                return model
-            })
-
-    update = (model = new Model())=>
-        this.myContext()
-            .where(model.key)
-            .update(model.entity)
-            .then(affected=>affected > 0)
-
-    delete = (model = new Model())=>
-        this.myContext()
-            .where(model.key)
-            .del()
-            .then(affected=>affected > 0)
-
-    get = (model = new Model())=>
-        this.myContext()
-            .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.Entity.build)
-            )
-}