Timo/requestor
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

adapt to modelling

Browse Source
This commit is contained in:
Timo Hocker 2020-05-02 21:29:25 +02:00
parent fccd69db74
commit 0eea261e56
6 changed files with 4062 additions and 4167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
lib/DatabaseCrudHandler.ts
View File

@ -1,29 +1,24 @@
import { Request, Response, Router } from 'express';
import { http } from '@scode/consts';
import { DatabaseCrudOptions } from './DatabaseCrudOptions';
import { ControlModel, DatabaseModel } from '@scode/modelling';
import { CrudHandler } from './CrudHandler';
import { HttpHandler } from './HttpHandler';
import { DatabaseCrudOptionsReader } from './DatabaseCrudOptionsReader';
export class DatabaseCrudHandler extends HttpHandler implements CrudHandler {
protected table: string;
protected columns: Array<string>;
protected cm: new () => ControlModel;
protected dm: new () => DatabaseModel;
protected options: DatabaseCrudOptionsReader;
public constructor (
public constructor<T extends ControlModel, U extends DatabaseModel> (
table: string,
columns: Array<string>,
options: DatabaseCrudOptions = {}
cm: new () => ControlModel,
dm: new () => DatabaseModel
) {
super ();
this.table = table;
this.columns = columns;
this.cm = cm;
this.dm = dm;
this.options = new DatabaseCrudOptionsReader (options);
if (this.columns.filter ((val) => val.toLowerCase () === 'id').length > 0) {
throw new Error (
'the column id cannot be made available to modification'
);
}
}
protected validate_body (
@ -45,29 +40,6 @@ export class DatabaseCrudHandler extends HttpHandler implements CrudHandler {
return null;
}
protected ensure_data (
data: Record<string, unknown>,
res: Response,
fail_on_undef = true
): Promise<Record<string, unknown>> | Record<string, unknown> {
const obj = {};
const keys = Object.keys (data);
for (const col of this.columns) {
if (!keys.includes (col) && fail_on_undef) {
res.status (http.status_bad_request)
.end (`missing field: ${col}`);
return null;
}
obj[col] = data[col];
}
if (typeof this.options.optional_columns !== 'undefined') {
for (const col of this.options.optional_columns)
obj[col] = data[col];
}
return obj;
}
public async create (req: Request, res: Response): Promise<void> {
if (!await this.options.create_authorization (req, res))
return;
@ -76,16 +48,17 @@ export class DatabaseCrudHandler extends HttpHandler implements CrudHandler {
if (body_data === null)
return;
const db_data = await this.ensure_data (body_data, res);
if (db_data === null)
return;
const cm = new this.cm;
cm.object = body_data;
cm.update ();
const inserted = await this.knex (this.table)
.returning ('id')
.insert (db_data);
const dm = new this.dm;
for (const key of Object.keys (body_data))
dm.set (key, cm.get (key));
await dm.write ();
res.status (http.status_created)
.end (inserted[0]);
.end (dm.id);
}
public async read (req: Request, res: Response): Promise<void> {
@ -98,14 +71,14 @@ export class DatabaseCrudHandler extends HttpHandler implements CrudHandler {
return;
}
const json = await this.knex (this.table)
.where ({ id: req.headers.id })
.select (
'id',
...this.columns
);
res.status (json.length > 0 ? http.status_ok : http.status_not_found)
.json (json[0]);
const dm = new this.dm (req.headers.id);
const found = await dm.read ();
const cm = new this.cm (dm.object);
cm.update ();
res.status (found ? http.status_ok : http.status_not_found)
.json (cm.object);
}
public async update (req: Request, res: Response): Promise<void> {
@ -116,21 +89,31 @@ export class DatabaseCrudHandler extends HttpHandler implements CrudHandler {
if (body_data === null)
return;
const db_data = await this.ensure_data (body_data, res, false);
if (db_data === null)
return;
if (typeof req.headers.id === 'undefined') {
res.status (http.status_bad_request)
.end ('id undefined');
return;
}
await this.knex (this.table)
.where ({ id: req.headers.id })
.update (db_data);
const dm = new this.dm (req.headers.id);
const found = await dm.read ();
if (!found) {
res.status (http.status_not_found)
.end ();
return;
}
res.status (http.status_ok)
const cm = new this.cm (dm.object);
cm.update ();
for (const key of Object.keys (body_data))
cm.set (key, body_data[key]);
cm.update ();
dm.object = cm.object;
const written = await dm.write ();
res.status (written ? http.status_ok : http.status_internal_server_error)
.end ();
}
@ -144,11 +127,17 @@ export class DatabaseCrudHandler extends HttpHandler implements CrudHandler {
return;
}
await this.knex (this.table)
.where ({ id: req.headers.id })
.delete ();
const dm = new this.dm (req.headers.id);
const found = await dm.read ();
if (!found) {
res.status (http.status_not_found)
.end ();
return;
}
res.status (http.status_ok)
const deleted = await dm.delete ();
res.status (deleted ? http.status_ok : http.status_internal_server_error)
.end ();
}

38
lib/DatabaseCrudOptionsReader.ts
View File

@ -1,15 +1,15 @@
import { Request, Response } from 'express';
import { KnexCrudOptions, Authorization } from './DatabaseCrudOptions';
import { DatabaseCrudOptions, Authorization } from './DatabaseCrudOptions';
type AuthRunner = {
(req: Request, res: Response): Promise<boolean>;
}
export class KnexCrudOptionsReader {
private options: KnexCrudOptions;
export class DatabaseCrudOptionsReader {
private _options: DatabaseCrudOptions;
public constructor (options: KnexCrudOptions) {
this.options = options;
public constructor (options: DatabaseCrudOptions) {
this._options = options;
}
private get_auth_runner (
@ -18,19 +18,23 @@ export class KnexCrudOptionsReader {
if (typeof auth === 'undefined')
return (): Promise<boolean> => new Promise ((r) => r (true));
return (req, res): Promise<boolean> => new Promise ((resolve) => {
const result = auth (req, res, resolve);
if (typeof result !== 'undefined')
resolve (result as boolean);
let resolved = false;
const result = await auth (req, res, (cb) => {
resolved = true;
resolve (typeof cb === 'undefined' || cb === true);
});
if (!resolved)
resolve (result);
});
}
public get optional_columns (): Array<string> | undefined {
return this.options.optional_columns;
return this._options.optional_columns;
}
public get create_authorization (): Authorization {
const general = this.get_auth_runner (this.options.general_authorization);
const specific = this.get_auth_runner (this.options.create_authorization);
const general = this.get_auth_runner (this._options.general_authorization);
const specific = this.get_auth_runner (this._options.create_authorization);
return async (req: Request, res: Response): Promise<boolean> => {
const result = (await general (req, res)) && (await specific (req, res));
return result;
@ -38,8 +42,8 @@ export class KnexCrudOptionsReader {
}
public get read_authorization (): Authorization {
const general = this.get_auth_runner (this.options.general_authorization);
const specific = this.get_auth_runner (this.options.read_authorization);
const general = this.get_auth_runner (this._options.general_authorization);
const specific = this.get_auth_runner (this._options.read_authorization);
return async (req: Request, res: Response): Promise<boolean> => {
const result = (await general (req, res)) && (await specific (req, res));
return result;
@ -47,8 +51,8 @@ export class KnexCrudOptionsReader {
}
public get update_authorization (): Authorization {
const general = this.get_auth_runner (this.options.general_authorization);
const specific = this.get_auth_runner (this.options.update_authorization);
const general = this.get_auth_runner (this._options.general_authorization);
const specific = this.get_auth_runner (this._options.update_authorization);
return async (req: Request, res: Response): Promise<boolean> => {
const result = (await general (req, res)) && (await specific (req, res));
return result;
@ -56,8 +60,8 @@ export class KnexCrudOptionsReader {
}
public get delete_authorization (): Authorization {
const general = this.get_auth_runner (this.options.general_authorization);
const specific = this.get_auth_runner (this.options.delete_authorization);
const general = this.get_auth_runner (this._options.general_authorization);
const specific = this.get_auth_runner (this._options.delete_authorization);
return async (req: Request, res: Response): Promise<boolean> => {
const result = (await general (req, res)) && (await specific (req, res));
return result;

8
package.json
View File

@ -23,17 +23,17 @@
},
"devDependencies": {
"@ava/typescript": "^1.1.1",
"@scode/eslint-config-ts": "^1.0.22",
"@scode/eslint-config-ts": "^1.0.27",
"@stryker-mutator/core": "^3.1.0",
"@stryker-mutator/javascript-mutator": "^3.1.0",
"ava": "^3.7.1",
"ava": "^3.8.1",
"eslint": "^6.8.0",
"nyc": "^15.0.1",
"typescript": "^3.8.3"
},
"dependencies": {
"@scode/consts": "^1.1.5",
"@scode/modelling": "^1.0.3",
"@scode/consts": "^1.1.7",
"@scode/modelling": "^1.0.9",
"@types/express": "^4.17.6",
"express": "^4.17.1"
}

20
test/.eslintrc.js
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) Sapphirecode - All Rights Reserved
* This file is part of Requestor which is released under BSD-3-Clause.
* See file 'LICENSE' for full license details.
* Created by Timo Hocker <timo@scode.ovh>, March 2020
*/
module.exports = {
env: {
commonjs: true,
es6: true,
node: true
},
extends: [
'@scode/eslint-config-ts'
],
rules: {
'node/no-unpublished-import': 'off'
}
}

88
test/KnexCrudHandler.ts
View File

@ -1,88 +0,0 @@
import knex from 'knex';
import test from 'ava';
import express, { Request, Response } from 'express';
import { http } from '@scode/consts';
import { KnexCrudHandler } from '../lib/DatabaseCrudHandler';
const db = knex ({
client: 'sqlite',
connection: { filename: './db.sqlite' }
});
/**
* general auth
*
* @param {any} req request
* @param {any} res response
* @returns {Promise<boolean>} successful response
*/
function general_auth (req: Request, res: Response): Promise<boolean> {
return new Promise ((resolve) => {
if (req.headers.auth === 'on') {
resolve (true);
}
else {
res.status (http.status_forbidden);
res.end ('auth failed');
resolve (false);
}
});
}
/**
* read auth
*
* @param {any} req request
* @param {any} res response
* @returns {Promise<boolean>} successful response
*/
function read_auth (req: Request, res: Response): Promise<boolean> {
return new Promise ((resolve) => {
if (req.headers.readauth === 'on') {
resolve (true);
}
else {
res.status (http.status_forbidden);
res.end ('readauth failed');
resolve (false);
}
});
}
test.before (async () => {
await db.schema.dropTableIfExists ('test');
await db.schema.createTable ('test', (t) => {
t.increments ('id');
t.string ('name');
t.integer ('number');
});
const no_auth = new KnexCrudHandler (db, 'test', [
'name',
'number'
], {});
const auth = new KnexCrudHandler (db, 'test', [ 'name' ], {
optional_columns: [ 'number' ],
general_authorization: general_auth,
read_authorization: read_auth
});
const app = express ();
app.use ('/test', no_auth.get_router ());
app.use ('/auth', auth.get_router ());
// eslint-disable-next-line no-magic-numbers
app.listen (3000);
});
test ('insert data', (t) => {});
test ('read data', (t) => {});
test ('update data', (t) => {});
test ('read updated data', (t) => {});
test ('[a] insert data', (t) => {});
test ('[a] insert data without auth', (t) => {});
test ('[a] insert data without optional column', (t) => {});
test ('[a] read data', (t) => {});
test ('[a] read data without auth', (t) => {});
test ('[a] read data without readauth', (t) => {});

7960
yarn.lock
View File

File diff suppressed because it is too large Load Diff