lambdaorm
Advanced tools
IMPORTANT: the library is in an Alpha version!!!
LambdaORM is an intermediary between the business model and the persistence of the data.
Completely decoupling the business model from the data layer.
For this use:
The lambda expressions are written based on the programming language itself, referring to the business model, completely abstracting from the database language and its structure.
Example:
User.map(p => {name: p.lastname + ', ' + p.firstname })
The engine also allows us to write the expressions in a string.
'User.map(p => {name: p.lastname + \', \' + p.firstname })'
It is the nexus between the business model and the persistence of the data.
The classes that represent the business model are completely clean, without any attributes that link them to persistence.
All the configuration necessary to resolve the relationship between the business model and persistence is done in the schema, which is configuration.
This configuration can be done in a yaml, json file or passed as a parameter when initializing the ORM.
The purpose of this ORM is to use javascript syntax to write query expressions. Which will be translated into the SQL statement corresponding to the database engine.
The schema defines how the entities of the model are mapped with the database tables.
In this scheme we can see how to extend entities.
To understand an entity we use the extends attribute in the definition of the entity
entities:
- name: Positions
abstract: true
properties:
- name: latitude
length: 16
- name: longitude
length: 16
- name: Countries
extends: Positions
In this scheme we can see how to extend the schema.
We use the extends attribute in the definition of the schema to extend it.
schemas:
- name: countries
- name: countries2
extends: countries
This schema has two entities that are in different databases.
The database attribute is used in the entity to be able to specify that an entity is in a database other than the default of the schema.
- name: States
database: mydb2
To work with the orm we can do it using the singleton object called "orm" or using repositories.
This orm object acts as a facade and from this we access all the functionalities.
To execute a query we have two methods
This method receives the expression as a javascript lambda function.
If we are going to write the expression in the code, we must do it with the lambda function, since in this way we will have the help of intellisense and we will make sure that the expression does not have syntax errors.
import { orm } from 'lambdaorm'
(async () => {
await orm.init()
const exp = (country:string)=>
Products.filter(p => (p.price > 5 && p.supplier.country == country) || (p.inStock < 3))
.having(p => max(p.price) > 50)
.map(p => ({ category: p.category.name, largestPrice: max(p.price) }))
.sort(p => desc(p.largestPrice))
const result = await orm.lambda(exp).execute({ country: 'USA' },'mydb')
console.log(JSON.stringify(result, null, 2))
await orm.end()
})()
where the SQL equivalent of the expression is:
SELECT c.CategoryName AS `category`, MAX(p.UnitPrice) AS `largestPrice`
FROM Products p
INNER JOIN Suppliers s ON s.SupplierID = p.SupplierID
INNER JOIN Categories c ON c.CategoryID = p.CategoryID
WHERE ((p.UnitPrice > 5 AND s.Country = ?) OR p.UnitsInStock < 3)
GROUP BY c.CategoryName
HAVING MAX(p.UnitPrice) > 50
ORDER BY `largestPrice` desc
This method receives the expression as a text string.
if the expression comes from somewhere else, UI, CLI command, persisted, etc, in this case we will use the expression in a string
import { orm } from 'lambdaorm'
(async () => {
await orm.init()
const country = 'USA'
const exp = `Products.filter(p => (p.price > 5 && p.supplier.country == country) || (p.inStock < 3))
.having(p => max(p.price) > 50)
.map(p => ({ category: p.category.name, largestPrice: max(p.price) }))
.sort(p => desc(p.largestPrice))`
const result = await orm.expression(exp).execute({ country: country },'mydb')
console.log(JSON.stringify(result, null, 2))
await orm.end()
})()
Repositories are associated with an entity and have several methods to interact with it.
Example:
import { orm } from 'lambdaorm'
import { ProductRespository } from './models/northwind'
(async () => {
await orm.init()
const productRepository = new ProductRespository('mydb')
const country = 'USA'
const result = awaitproductRepository.query().filter(p => (p.price > 5 && p.supplier.country === country) || (p.inStock < 3))
.having(p => max(p.price) > 50)
.map(p => ({ category: p.category.name, largestPrice: max(p.price) }))
.sort(p => desc(p.largestPrice))
.execute({ country: country })
console.log(JSON.stringify(result, null, 2))
await orm.end()
})()
To write the expressions we use methods, operators and functions.
Starting from the entity we have the following methods.
| Method | Description | SQL Equivalent | |
|---|---|---|---|
| filter | To filter the records. | WHERE | more info |
| having | To filter on groupings. | HAVING | more info |
| map | To specify the fields to return. | SELECT | more info |
| distinct | to specify the fields to return by sending duplicate records. | more info | |
| first | returns the first record | SELECT + ORDER BY + LIMIT | more info |
| last | returns the last record | SELECT + ORDER BY DESC + LIMIT | more info |
| take | returns one record | SELECT + LIMIT | more info |
| sort | To specify the order in which the records are returned. | ORDER BY | more info |
| page | To paginate. | LIMIT (MySQL) | more info |
| include | To get records of related entities | more info | |
| insert | To insert records | INSERT | more info |
| update | To update records always including a filter | UPDATE with WHERE | more info |
| updateAll | to be able to update all the records of an entity | UPDATE without WHERE | more info |
| delete | To delete records always including a filter | DELETE with WHERE | more info |
| deleteAll | To be able to delete all records of an entity | DELETE without WHERE | more info |
| bulkinsert | to insert records in bulk | INSERT | more info |
There are no methods for the INNER JOIN clause since it is deduced when navigating through the relations of a property.
There are no methods for the GROUP BY clause since this is deduced when grouping methods are used.
The operators used are the same as those of javascript.
below access to their documentation:
| Category | Operators | |
|---|---|---|
| Arithmectic | -, +, *, /, **, //, % | more info |
| Bitwise | ~,&,^,<<,>> | more info |
| Comparison | ==, ===, !=, !==, >, <, >=, <= | more info |
| Logical | !, && | more info |
| Array | [] | more info |
In the case of functions, some correspond to javascript functions and others are specific to sql
below access to their documentation:
| Category | functions | |
|---|---|---|
| Numeric | abs,ceil,cos,exp,ln,log,remainder,round,sign,sin,tan,trunc... | more info |
| String | chr,lower,lpad,ltrim,replace,rpad,rtrim,substr,trim,upper,concat... | more info |
| Datetime | curtime,today,now,time,date,datetime,year,month,day,weekday,hours... | more info |
| Convert | toString,toJson,toNumber | more info |
| Nullable | nvl,nvl2,isNull,isNotNull | more info |
| General | as,distinct | more info |
| Sort | asc,desc | more info |
| Conditionals | between,includes | more info |
| Group | avg,count,first,last,max,min,sum | more info |
| Metadata | user,source | more info |
LambdaORM includes the Include method to load related entities, both for OnetoMany, manyToOne and oneToOne relationships.
We can also apply filters or bring us some fields from the related entities.
For each include, a statement is executed bringing all the necessary records, then the objects with relationships are assembled in memory. In this way, multiple executions are avoided, considerably improving performance.
Includes can be used in selects, insert, update, delete, and bulckinsert.
Example:
import { orm } from 'lambdaorm'
(async () => {
await orm.init()
const expression = (id:number) => Orders
.filter(p => p.id === id)
.include(p => [p.customer.map(p => ({ name: p.name, address: concat(p.address, ', ', p.city, ' (', p.postalCode, ') ', p.country) })),
p.details.include(p => p.product
.include(p => p.category.map(p => p.name))
.map(p => p.name))
.map(p => [p.quantity, p.unitPrice])])
.map(p => p.orderDate)
const result = await orm.lambda(expression).execute('mydb')
console.log(JSON.stringify(result, null, 2))
await orm.end()
})()
The previous sentence will bring us the following result:
[[
{
"orderDate": "1996-07-03T22:00:00.000Z",
"customer": { "name": "Vins et alcools Chevalier", "address": "59 rue de l'Abbaye, Reims (51100) France"
},
"details": [
{
"quantity": 12, "unitPrice": 14,
"product": { "name": "Queso Cabrales", "category": { "name": "Dairy Products"}
}
},
{
"quantity": 10, "unitPrice": 9.8,
"product": { "name": "Singaporean Hokkien Fried Mee", "category": { "name": "Grains/Cereals" }}
},
{
"quantity": 5, "unitPrice": 34.8,
"product": { "name": "Mozzarella di Giovanni", "category": { "name": "Dairy Products" } }
}
]
}
]]
To work with transactions use the orm.transaction method.
This method receives the name of the database as the first argument and as the second it is a callback function that does not pass a Transaction object, in the example we name it tr.
We use the lambda or expression method to execute the sentence (as we found it written).
When we reach the end and return the callback, the orm will internally execute the COMMIT, if there is an exception, internally the ROLLBACK will be executed
Example
import { orm } from 'lambdaorm'
(async () => {
const order={customerId:"VINET",employeeId:5,orderDate:"1996-07-03T22:00:00.000Z",requiredDate:"1996-07-31T22:00:00.000Z",shippedDate:"1996-07-15T22:00:00.000Z",shipViaId:3,freight:32.38,name:"Vins et alcools Chevalier",address:"59 rue de l-Abbaye",city:"Reims",region:null,postalCode:"51100",country:"France",details:[{productId:11,unitPrice:14,quantity:12,discount:!1},{productId:42,unitPrice:9.8,quantity:10,discount:!1},{productId:72,unitPrice:34.8,quantity:5,discount:!1}]};
try {
orm.transaction('mydb', async (tr) => {
// create order
const orderId = await tr.lambda(() => Orders.insert().include(p => p.details), order)
// get order
const result = await tr.lambda((id:number) => Orders.filter(p => p.id === id).include(p => p.details), { id: orderId })
const order2 = result[0]
// updated order
order2.address = 'changed 59 rue de l-Abbaye'
order2.details[0].discount = true
order2.details[1].unitPrice = 10
order2.details[2].quantity = 7
const updateCount = await tr.lambda(() => Orders.update().include(p => p.details), order2)
console.log(updateCount)
// get order
const order3 = await tr.lambda((id:number) => Orders.filter(p => p.id === id).include(p => p.details), { id: orderId })
console.log(JSON.stringify(order3))
// delete
const deleteCount = await tr.lambda(() => Orders.delete().include(p => p.details), order3[0])
console.log(deleteCount)
// get order
const order4 = await tr.lambda((id:number) => Orders.filter(p => p.id === id).include(p => p.details), { id: orderId })
console.log(JSON.stringify(order4))
})
} catch (error) {
console.log(error)
}
})()
When the orm.init () method is invoked, the initialization of the orm will be executed from the configuration.
This configuration contains the main sections, paths, databases and schemas.
Example:
{
"app:": { "src": "src", "data": "data" ,"models":"models","defaultDatabase": "mydb" },
"databases": [
{
"name": "mydb",
"dialect": "mysql",
"schema": "location",
"connection": "$CNN_MYSQL"
}
],
"schemas": [
{
"name": "location",
"enums": [],
"entities": [
{
"name": "Country",
"mapping": "COUNTRY",
"primaryKey": [ "id" ],
"uniqueKey": [ "name" ],
"properties": [
{ "name": "id", "mapping": "ID", "type": "integer","nullable": false },
{ "name": "name","mapping": "NAME", "nullable": false, "type": "string", "length": 127 },
{ "name": "alpha2","mapping": "ALPHA_2", "nullable": false,"type": "string","length": 2 },
{ "name": "alpha3", "mapping": "ALPHA_3", "nullable": false, "type": "string", "length": 3 }
]
}
]
}
]
}
There are the following options to define the settings.
Invoke the orm.init () method without the first argument and write this configuration in a file called lambdaorm.json or lambdaorm.yaml in the root of the project. according to the lambdaorm extension you will know how to read it.
Invoke the orm.init () method, pass as an argument the path where the configuration file is located. This path must include the extension .yaml or .json since this way we will know how to read it.
Invoke the orm.init () method passing the configuration as a json object as an argument
Example passing the path of the configuration file:
import { orm } from 'lambdaorm'
(async () => {
await orm.init('/home/my/db/book.yaml')
try {
const result = await orm.expression('Loan.map(p=>{user:p.reader.name,book:p.book.title,date:p.date})').execute('mydb')
console.log(result)
} catch (error) {
console.log(error)
} finally {
await orm.end()
}
})()
Lambda ORM has the following methods to extract metadata information from expressions.
To execute these methods it is not necessary to connect to the database.
| method | Description | Path |
|---|---|---|
| parameters | returns the list of parameters in the expression | orm.lambda(query).parameters(schema) |
| model | returns the model of the result in an execution | orm.lambda(query).model(schema) |
| metadata | returns the metadata of the expression | orm.lambda(query).metadata(schema) |
| sentence | returns the sentence in the specified dialect | orm.lambda(query).sentence('mysql','northwind') |
npm install lambdaorm
Install the package globally to use the CLI commands to help you create and maintain projects
npm install lambdaorm-cli -g
In this laboratory we will see:
Creating the northwind sample database tables and loading it with sample data. This database presents several non-standard cases such as: - Name of tables and fields with spaces - Tables with composite primary keys - Tables with autonumeric ids and others with ids strings
Since this is the database that was used for many examples and unit tests, you can test the example queries that are in the documentation. We will also see some example queries to execute from CLI
In this laboratory we will see:
In this laboratory we will see:
In this laboratory we will see:
In this laboratory we will see:
FAQs
ORM
The npm package lambdaorm receives a total of 23 weekly downloads. As such, lambdaorm popularity was classified as not popular.
We found that lambdaorm demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
A malicious Maven package typosquatting a popular library is secretly stealing OAuth credentials on the 15th of each month, putting Java developers at risk.
Security News
Socket and Seal Security collaborate to fix a critical npm overrides bug, resolving a three-year security issue in the JavaScript ecosystem's most popular package manager.
Security News
TypeScript is porting its compiler to Go, delivering 10x faster builds, lower memory usage, and improved editor performance for a smoother developer experience.