An implementation of basic entity framework functionnalities in typescript
npm install slim-efslim-ef is a wrapper around typeorm. Typeorm is a pretty complete orm. which offers a lot of tools form mapping rowdata with models. Most of these functinnalities have been abstracted by slim-ef, but you still need to write your models with typeorm's decorators (@Column, @OnetoMany, etc...). Future versions of slim-ef may abstract these decorators too.
.where((t,$)=> t.name.includes($.name) than writing a string literal "entity.name like 'buggy".
npm i slim-ef
`
$3
#### Setup
The design of this api was made in such a way that it ressemble as much as possible to entity framework
First you need to create your various models using the typeorm decorators as specified here
Then you need to create a DbContext class that will inherit from slim-ef's DbContext.
`ts
...
import { Connection } from 'typeorm';
import {
DbContext,
DbSet,
DbSetEntity,
IDbSet,
SQLQuerySpecificationEvaluator
} from 'slim-ef';
import { IDbContextOptionsBuilder, DbContextModelBuilder } from 'slim-ef/uow';
export class FakeDBContext extends DbContext {
constructor() {
/**
* SQLite connection
*/
super(
new Connection({
type: 'sqlite',
database: resolve(__dirname, 'seeder', 'slim_ef_test.db'),
entities: [Person, Agency, Trip],
synchronize: false
} as SqliteConnectionOptions),
SQLQuerySpecificationEvaluator
);
}
protected onModelCreation(
builder: DbContextModelBuilder
): void {
builder.entity(Person).hasQueryFilter(q => q.where(e => e.IDNumber > 50));
}
protected onConfiguring(optionsBuilder: IDbContextOptionsBuilder): void {
optionsBuilder.useLoggerFactory({
createLogger: (catName: string) => ({
log: (level, state) => console.log({ catName, state, level })
})
});
}
@DbSetEntity(Person)
public readonly persons: IDbSet;
@DbSetEntity(Agency)
public readonly agencies: IDbSet;
@DbSetEntity(Trip)
public readonly trips: IDbSet;
}
`
The FakeDbContext here represents our data strore. Each property marked with @DbSetEntity are data sets (collection of thier specifique type).
Slim-ef's DbContext abstract class constructor takes as param an instance TypeOrm Connection and an a specification evaluator. There is already a default implementation of a query specification evaluator in slim-ef (SQLQuerySpecificationEvaluator). You can just import it and use it.
The child DbContext needs to override onModelCreation & onConfiguring. In this version DbContextModelBuilder and IDbContextOptionsBuilder only permits you to add query filters and logger handlers respectively.
#### Availaible APIs
Data Store available APIs
`ts
interface IDbContext {
/**
* Begins tracking the given entity, and any other reachable entities that are not
* already being tracked, in the Added state such that they will be inserted
* into the database when saveChanges() is called.
* @param entities
*/
add(...entities: T[]): Promise | void;
/**
* Begins tracking the given entity and entries reachable from the given entity using
* the Modified state by default such that they will be updated
* in the database when saveChanges() is called.
* @param entities
*/
update(...entities: T[]): Promise | void;
/**
* Begins tracking the given entity in the Deleted state such that it will be removed
* from the database when saveChanges() is called.
* @param entities
*/
remove(...entities: T[]): Promise | void;
/**
* Removes entities from the list of currently tracked entities
* @param entities
*/
unTrack(...entities: T[]): Promise | void;
/**
* Finds an entity with the given primary key values. If an entity with the given
* primary key values is being tracked by the context, then it is returned
* immediately without making a request to the database. Otherwise, a query is made
* to the database for an entity with the given primary key values and this entity,
* if found, is attached to the context and returned. If no entity is found, then
* undefined is returned.
* @param type The entity type
* @param id The entity id
*/
find(type: new (...args: any) => T, id: any): Promise | T;
/**
* Creates a database connextion and executes the given query
* @param query
* @param parameters
*/
query(query: string, parameters: any[]): Promise;
/**
* Discard all they tracked modifications of all entity types or a specific type
* @param entityType
*/
rollback(entityType: any | undefined): void;
/**
* Creates a DbSet that can be used to query and save instances of TEntity.
* @param type
*/
set(type: new (...args: any) => T): IDbSet;
/**
* Saves all changes made in this context to the database.
* This method will automatically call DetectChanges() to discover any changes to
* entity instances before saving to the underlying database.
*/
saveChanges(): void;
/**
* Releases the allocated resources for this context.
*/
dispose(): void;
}
`
Collection available APIs
`ts
interface IDbSet {
constructor(context: IDbContext);
/**
* Begins tracking the given entity, and any other reachable entities that are not
* already being tracked, in the Added state such that they will be inserted
* into the database when saveChanges() is called.
* @param entities
*/
add(...entities: DT[]): Promise | void;
/**
* Begins tracking the given entity and entries reachable from the given entity using
* the Modified state by default such that they will be updated
* in the database when saveChanges() is called.
* @param entities
*/
update(...entities: DT[]): Promise | void;
/**
* Begins tracking the given entity in the Deleted state such that it will be removed
* from the database when saveChanges() is called.
* @param entities
*/
remove(...entities: DT[]): Promise | void;
/**
* Removes entities from the list of currently tracked entities
* @param entities
*/
unTrack(...entities: DT[]): Promise | void;
/**
* Finds an entity with the given primary key values. If an entity with the given
* primary key values is being tracked by the context, then it is returned
* immediately without making a request to the database. Otherwise, a query is made
* to the database for an entity with the given primary key values and this entity,
* if found, is attached to the context and returned. If no entity is found, then
* undefined is returned.
* @param type The entity type
* @param id The entity id
*/
find(id: any): Promise | T;
/**
* Checks if an entity with the given id exists in the data store
* @param id
*/
exists(id: any): Promise;
/**
* Asynchronously returns the first element of the sequence
*/
first(): Promise;
/**
* Asynchronously returns the first element of the sequence that satisfies a specified condition.
* @param predicate A function to test each element for a condition.
* @param context The predicate data source
*/
first(
predicate: SlimExpressionFunction,
context?: C
): Promise;
/**
* Asynchronously returns the first element of a sequence, or a default value if the sequence contains no elements.
*/
firstOrDefault(): Promise;
/**
* Asynchronously returns the first element of a sequence that satisfies a specified condition
* or a default value if no such element is found.
* @param predicate A function to test each element for a condition.
* @param context The predicate data source
*/
firstOrDefault(
predicate: SlimExpressionFunction,
context?: C
): Promise;
/**
* Asynchronously creates aa Array of result from IQueryable by enumerating it asynchronously.
*/
toList(): Promise;
/**
* Specifies related entities to include in the query results. The navigation property
* to be included is specified starting with the type of entity being queried (TEntity).
* If you wish to include additional types based on the navigation properties of
* the type being included, then chain a call to thenInclude after this call.
* @param navigationPropertyPath The type of the related entity to be included.
*/
include(
navigationPropertyPath: SlimExpressionFunction
): IQueryable & IQueryable;
/**
* Specifies additional related data to be further included based on a related type
* that was just included.
* @param navigationPropertyPath The type of the related entity to be included.
*/
thenInclude(
navigationPropertyPath: SlimExpressionFunction
): IQueryable & IQueryable;
/**
* Filters the sequence based on a predicate.
* @param predicate A function to test each element for a condition.
* @param context The predicate data source
*/
where(
predicate: SlimExpressionFunction,
context?: C
): IQueryable;
/**
* Returns a specified number of contiguous elements from the start of the sequence.
* @param count The number of elements to return.
*/
take(count: number): IQueryable;
/**
* Bypasses a specified number of elements in a sequence and then returns the remaining elements.
* @param count The number of elements to skip before returning the remaining elements.
*/
skip(count: number): IQueryable;
/**
* Computes the sum of the sequence of number values that is obtained by
* invoking a projection function on each element of the input sequence.
* @param selector A projection function to apply to each element.
*/
sum(selector: SlimExpressionFunction): Promise;
/**
* Computes the average of a sequence of number values that is obtained by
* invoking a projection function on each element of the input sequence.
* @param selector A projection function to apply to each element.
*/
average(selector: SlimExpressionFunction): Promise;
/**
* Returns the number of elements in the specified sequence. If condition is provided,
* the resulting elements will satisfy the condition.
* @param predicate A function to test each element for a condition.
*/
count(
predicate?: SlimExpressionFunction
): Promise;
/**
* Invokes a projection function on each element of the sequence
* and returns the maximum resulting value.
* @param selector A projection function to apply to each element.
*/
max(
selector: SlimExpressionFunction
): Promise;
/**
* Invokes a projection function on each element of the sequence
* and returns the minimum resulting value.
* @param selector A projection function to apply to each element.
*/
min(
selector: SlimExpressionFunction
): Promise;
/**
* Projects each element of a sequence into a new form.
* @param selector A projection function to apply to each element.
*/
select(
selector: SlimExpressionFunction
): IQueryableSelectionResult;
/**
* Specifies that the current query should not have any
* model-levelentity query filters applied.
*/
ignoreQueryFilters(): IQueryable;
/**
* Sorts the elements of a sequence in descending order according to a key.
* @param keySelector A function to extract a key from an element.
*/
orderBy(keySelector: SlimExpressionFunction): IQueryable;
/**
* Performs a subsequent ordering of the elements in a sequence in ascending order
* @param keySelector
*/
thenOrderBy(keySelector: SlimExpressionFunction): IQueryable;
/**
* Sorts the elements of a sequence in ascending order according to a key.
* @param keySelector A function to extract a key from an element.
*/
orderByDescending(keySelector: SlimExpressionFunction): IQueryable;
}
`
#### Examples
You can play around and do stuffs like this :smile:
`ts
...
const context = new DeltaTravelDBContext();
const pd = {
departureDate: new Date(2000, 1, 1),
estimatedArrivalDate: new Date(2016, 1, 1)
};
const tripsQuery = context.trips
.include(t => t.agency)
.include(t => t.passengers)
.where(
(t, $) =>
t.departureDate > $.departureDate &&
(t.estimatedArrivalDate < $.estimatedArrivalDate ||
t.passengers.some(p => p.willTravel === true)),
pd
)
.select(
t =>
new TripResponse(
t.agency.name,
t.agency.email,
t.departureDate,
t.passengers.map(p => ({
name: p.lastname ,
phone: p.phone,
ID: p.IDNumber
}))
)
);
const res = await tripsQuery.toList();
`
For detail examples see : Slim-ef-examples
Not YET Supported
- The select api doesnot support operation evaluation, only direct assignation is supported i.e
`ts
...
const tripsQuery = context.trips
.include(t => t.agency)
.include(t => t.passengers)
.select(
t =>
new TripResponse(
t.agency.name,
t.agency.email,
t.departureDate,
t.passengers.map(p => ({
name: p.lastname + ' ' + p.firstName, // <- Not supported
phone: p.phone,
ID: p.IDNumber,
anotherOne: p.lastname.includes('something'), // <- Not supported
andAlso: p.IDNumber > 8520 // <- Not supported
}))
)
);
`
TO DO
- Change tracking
- Improve select` api