sliced/index.js

(async() => {
    const Sequelize = require("sequelize");
	const Op = Sequelize.Op
    const sequelize = new Sequelize("test", "","",{
		host: 'localhost',
		dialect: 'mysql',

		pool: {
			max: 5,
			min: 0,
			idle: 10000
		},
		//logging: false
	});

	const Slice = sequelize.define("slice",{
		permission: Sequelize.STRING, //create, update, delete, read, etc
		model: Sequelize.STRING,
		modelId: Sequelize.INTEGER,
		//plain list of: "tags" like: admin, manager, user, anon, User can be tagged by this word in string list variable
		//OR: just userId.
		//OR, if negative number (or hash #100500) - other slice id (use abs to get proper table id)
		//this way optimizing 
		slice: {type: Sequelize.TEXT, //PROBABLY STRING
			get(){
				return this.getDataValue("slice").split(",")
			},
			set(newValue){ //TODO: update users before with groups
				newValue = "length" in newValue ? newValue.join(",") : newValue
				return this.setDataValue("slice", newValue)
			}
		}
		},{
		getterMethods: {
			async all(){
				if (this._all) return this._all

				this._subSlicesList = this.slice.filter(id => id[0] == "#" || id[0] == "-") //detect - or #
												.map(   id => +id.substr(1)) //cut first char + toInt
				this._roles         = this.slice.filter(id => id[0] >= 'a' && id[0] <= 'z' )
				this._userIds       = this.slice.filter(id => id[0] >= '0' && id[0] <= '9' )

				if (this._subSlicesList.length) {
					let subSlices = await Slice.findAll({where: {id: {[Op.in]: this._subSlicesList}}})
					if (subSlices) for (let subSlice of subSlices){
						this._subSlicesList = this._subSlicesList.filter(id => subSlice.id !== id)
						let   subSliceAll   = await subSlice.all
						this._subSlicesList = [...this._subSlicesList,... subSliceAll.slices]
						this._roles         = [...this._roles,        ...subSliceAll.roles]
						this._userIds       = [...this._userIds,      ...subSliceAll.userIds]
					}
				}

				this._all = {slices: this._subSlicesList, roles: this._roles, userIds: this._userIds}

				return this._all
			},
			async allRoles(){
				return (await this.all).roles
			},
			async allSlices(){
				return (await this.all).slices
			},
			async allUserIds(){
				return (await this.all).userIds
			},

			roles(){
				return this.slice.filter(id => id[0] >= 'a' && id[0] <= 'z' )
			},

			groups(){
				return this.slice.filter(id => id[0] == "#" || id[0] == "-") //detect - or #
												.map(   id => +id.substr(1)) //cut first char + toInt
			}
		},
		indexes: [
			{
				fields: ["modelId", "model", "permission"]
			},
		]
	})


	const User = sequelize.define("user", {
		login: Sequelize.STRING,
		password: Sequelize.STRING,
	})

	const Content = sequelize.define("content", {
		title: Sequelize.STRING,
		data: Sequelize.TEXT
	})

	async function filldb(){
		await sequelize.sync()

		console.log('synced')

		let [vasya, petya, kolya] = await Promise.all([
			User.create({login: "Vasya", password: "qwe"}), 
			User.create({login: "Petya", password: "qwe"}),
			User.create({login: "Kolya", password: "qwe"}),
		])

		let groupSlice = await Slice.create({
			permission: 'group',
			model: 'group',
			slice: [`${vasya.id}`, `${petya.id}`]
		})

		let [vasyaSlice, petyaSlice, kolyaSlice] = await Promise.all([
			Slice.create({model: 'user', permission: 'user', modelId: vasya.id, slice: ["user", `#${groupSlice.id}`]}),
			Slice.create({model: 'user', permission: 'user', modelId: petya.id, slice: ["user", `#${groupSlice.id}`]}),
			Slice.create({model: 'user', permission: 'user', modelId: kolya.id, slice: ["user" ]})
		])

		let [hiddenContent, roleContent, groupContent] = await Promise.all([
			Content.create({title: 'Hidden', data: 'HIDDEN'}),
			Content.create({title: 'Role', data: 'ROLE'}),
			Content.create({title: 'Group', data: 'GROUP'}),
		])

		let [hiddenSlice, roleSlice, groupContentSlice] = await Promise.all([
			Slice.create({model: 'content', permission: 'read', modelId: hiddenContent.id, slice: []}),
			Slice.create({model: 'content', permission: 'read', modelId: roleContent.id, slice: ["user"]}),
			Slice.create({model: 'content', permission: 'read', modelId: groupContent.id, slice: [`#${groupSlice.id}`]}),
		])
	}

	//filldb()

	function sliced(model){
		return async userId => {
			let  user = await User.findByPk(userId)
			if (!user) throw new ReferenceError(`user with userId ${userId} doesn't exists`)

			let userSlice = await Slice.findOne({where: {
				model: 'user', //TODO configure this
				modelId: userId,
				permission: 'user'
			}})


			let [userRoles, userGroups] = [userSlice.roles, userSlice.groups]

			//console.log(userRoles, userGroups)

			let mapMethodToPermission = {
				read:  ["count",  "findAll", "findAndCountAll", "findByPk",  "findOne",  "max", "min", "sum"],
				write: ["create", "destroy","findCreateFind","findOrCreate","update","upsert" ]
			}

			//sequelize.addHook('beforeCreate', (...params) => console.log(params))
			let modelProxy =  new Proxy(model, {
				get(model, method){
					let found = false
					for (var permission in mapMethodToPermission)  {
						if (mapMethodToPermission[permission].includes(method)){
							found = true
							break;
						}
					}
					if (!found){
						console.log(`not found ${method}`)
						return model[method]
					}
					let checker    = async slice => {
						let intersect = (await slice.allRoles).filter(role => userRoles.includes(role))
						return (intersect.length || (await slice.allUserIds).includes(userId + '')) 					
					}
					let wrappers   = {
						async read(...params){
							console.log('read wrapper')
							let result =  await model[method](...params)
							if (result instanceof Array){
								let ids = result.map(instance => instance.id)
								let slices = await Slice.findAll({where: {
																		model: model.getTableName(), 
																		modelId: {[Op.in]: ids},
																		permission,
																	}})
								let filteredResult = []
								for (let slice of slices){
									let instance  = result.filter(instance => instance.id === slice.modelId)[0]
									//role check
									if (await checker(slice)) {
										filteredResult.push(instance)
										continue;
									}
								}
								return filteredResult
							}
							if ('id' in result){ //one record
								let slice = await Slice.findOne({where: {
																		model: model.getTableName(), 
																		modelId: result.id,
																		permission,
																	}})
								return (await checker(slice)) ? result : null;
							}
						}
					}
					return wrappers[permission]
				},
			})

			return modelProxy
		}
	}

	let SlicedContent = await sliced(Content)(3)

	let allContent    = await SlicedContent.findByPk(3)
	console.log(allContent)



	let delay = ms => new Promise(r => setTimeout(r, ms))
})()