- Potentially use TypedBuilder crate
- Consider JSON Schema for defining types with Typify
- Maybe even better, ability to generate JSON schema from Rust types with schemars
See: https://github.com/kurtbuilds/ormlite
Relies on:
export DATABASE_URL=postgres://postgres:postgres@localhost:5432/postgresCreate db
# Create the database if it doesn't exist
# For postgres, that is: createdb <dbname>
ormlite initormlite up- Executes migrationsormlite migrate initial- Auto generates migrations based on rust structs
Permission system
- Field level permissions
Q: Entity vs model permissions?
Built-in permissions + extended
Groups: Owner, Admin, User, Guest CRUD, CRUD, CRUD, CRUD
Actually, maybe both should have permissions? But, hmm, ... -> Model | check_permissions I think model only needs permissions... Export usual permissions???
Base permissions are required for each model defined. Base permissions are known at compile time Therefore, those permissions can easily get exported by the API
- Not part of the initial version
- Should be doable after backend is fully complete, probably better then
src/api
- import export types
- export builtin permissions
- export manip functions
use resin::api::{User} api.create(User { firstname : "John", lastname : "Doe" })
with macros, easily can do: api.CreateUser(User{ ... })
- Separate nix files for resin and postgres database
- Create a separate project for PG database to be used with different apps
- It should be configurable and it could run via shell script or directly through nix
- Fix rust analyzer running inside the nix
Eventually, resin can be a framework for easily constructing REST APIs
See: Proof of concept implementation
NOTE: This is done through boilermates now
use resin::{Entity, Model};
#[derive(Entity, Model)]
#[resin(table = "people", insertable = InsertPerson)]
struct Person {
id: i32,
name: String,
age: i32,
}Which would generate
Entity:
#[derive(Serialize, Deserialize)]
pub struct PersonEntity {
pub id: i32,
pub name: String,
pub age: i32,
}Model:
#[derive(Model, Debug)]
#[ormlite(table = "people", insertable = InsertPerson)]
pub struct Person {
pub id: i32,
pub name: String,
pub age: i32,
}psql- Open postgres shell\dt- Show tablesSELECT * FROM <table-name>;- Show table
- If the direction is that the resin library should be crated
- Then, we can create resin (resin-core) folder, and also have resin-macros and maybe some more
More idea on having a single model for Model and Entity
#derive(Debug)
#entity_derive(Serialize,Deserialize)
struct User {
id: i32,
name: String,
age: i32,
#[entity_field]
age: i32,
#[model_field]
born: Date,
}Goals:
- Reduce boilerplate code
- Lower the possibility for error
It would be good to consider making this even more generic
#[multi_struct(UserModel, UserEntity)]
// Optionally the union struct can be kept
#[multi_struct_keep_original]
#derive(Debug)
struct User {
id: i32,
name: String,
age: i32,
#[only(UserEntity)]
age: i32,
#[only(UserModel)]
born: Date,
}