@proteinjs/db 1.0.2

package/src/Db.ts

@@ -0,0 +1,195 @@
+import { DbService, Query, getDbService } from './services/DbService';
+import { Service } from '@proteinjs/service';
+import { Loadable, SourceRepository } from '@proteinjs/reflection';
+import { Column, Table, getColumnPropertyName, tableByName } from './Table';
+import { Record, RecordSerializer, SerializedRecord } from './Record';
+import { Logger } from '@proteinjs/util';
+import { SourceRecordLoader } from './source/SourceRecordLoader';
+import { ParameterizationConfig, QueryBuilder, Statement, StatementFactory } from '@proteinjs/db-query';
+import { QueryBuilderFactory } from './QueryBuilderFactory';
+import { StatementConfigFactory } from './StatementConfigFactory';
+import { TableManager } from './schema/TableManager';
+import { TableAuth } from './auth/TableAuth';
+import { TableServiceAuth } from './auth/TableServiceAuth';
+
+export const getDb = <R extends Record = Record>() => typeof self === 'undefined' ? new Db<R>() : getDbService() as Db<R>;
+export const getSystemDb = <R extends Record = Record>() => new Db<R>(undefined, undefined, true);
+
+export type DbDriverStatementConfig = ParameterizationConfig & { prefixTablesWithDb?: boolean }
+
+export interface DbDriver extends Loadable {
+    getDbName(): string;
+    createDbIfNotExists(): Promise<void>;
+    start?(): Promise<void>;
+    stop?(): Promise<void>;
+    getTableManager(): TableManager;
+    runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<SerializedRecord[]>;
+    runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number>; // returns the number of affected rows
+}
+
+export class Db<R extends Record = Record> implements DbService<R> {
+    private static globalDbDriver: DbDriver;
+    private dbDriver: DbDriver;
+    private logger = new Logger(this.constructor.name);
+    private statementConfigFactory: StatementConfigFactory;
+    private auth = new TableAuth();
+    public serviceMetadata: Service['serviceMetadata'] = {
+        auth: {
+            canAccess: (methodName, args) => new TableServiceAuth().canAccess(methodName, args),
+        },
+    };
+
+    constructor(
+        dbDriver?: DbDriver,
+        getTable?: (tableName: string) => Table<any>,
+        private ignoreAuth?: boolean
+    ) {
+        this.dbDriver = dbDriver ? dbDriver : this.getGlobalDbDriver();
+        this.statementConfigFactory = new StatementConfigFactory(this.dbDriver.getDbName(), getTable);
+    }
+
+    private getGlobalDbDriver(): DbDriver {
+        if (!Db.globalDbDriver) {
+            Db.globalDbDriver = SourceRepository.get().object<DbDriver>('@proteinjs/db/DbDriver');
+            if (!Db.globalDbDriver)
+                throw new Error(`Unable to find @proteinjs/db/DbDriver implementation. Make sure you've included one as a package dependency.`);
+        }
+
+        return Db.globalDbDriver;
+    }
+
+    async init(): Promise<void> {
+        await this.dbDriver.createDbIfNotExists();
+        await this.dbDriver.getTableManager().loadTables();
+        await new SourceRecordLoader().load();
+    }
+
+    async tableExists<T extends R>(table: Table<T>): Promise<boolean> {
+        return await this.dbDriver.getTableManager().tableExists(table);
+    }
+
+    async get<T extends R>(table: Table<T>, query: Query<T>): Promise<T> {
+        return (await this.query(table, query))[0];
+    }
+
+    async insert<T extends R>(table: Table<T>, record: Omit<T, keyof R>): Promise<T> {
+        if (!this.ignoreAuth)
+            this.auth.canInsert(table);
+
+        const recordCopy = Object.assign({}, record);
+        await this.addDefaultFieldValues(table, recordCopy);
+        const recordSearializer = new RecordSerializer(table);
+        const serializedRecord = await recordSearializer.serialize(recordCopy);
+        const generateInsert = (config: DbDriverStatementConfig) => new StatementFactory<T>().insert(table.name, serializedRecord as Partial<T>, this.statementConfigFactory.getStatementConfig(config));
+        await this.dbDriver.runDml(generateInsert);
+        return recordCopy as T;
+    }
+
+    private async addDefaultFieldValues<T extends R>(table: Table<T>, record: any) {
+        for (let columnPropertyName in table.columns) {
+            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+            if (column.options?.defaultValue && typeof record[columnPropertyName] === 'undefined')
+                record[columnPropertyName] = await column.options.defaultValue(record);
+        }
+    }
+
+    async update<T extends R>(table: Table<T>, record: Partial<T>, query?: Query<T>): Promise<number> {
+        if (!this.ignoreAuth)
+            this.auth.canUpdate(table);
+
+        if (!query && !record.id)
+            throw new Error(`Update must be called with either a QueryBuilder or a record with an id property`);
+
+        const recordCopy = Object.assign({}, record);
+        await this.addUpdateFieldValues(table, recordCopy);
+        const recordSearializer = new RecordSerializer<T>(table);
+        const serializedRecord = await recordSearializer.serialize(recordCopy);
+        const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
+        if (!query)
+            qb.condition({ field: 'id', operator: '=', value: recordCopy.id as T[keyof T] });
+            
+        const generateUpdate = (config: DbDriverStatementConfig) => new StatementFactory<T>().update(table.name, serializedRecord as Partial<T>, qb, this.statementConfigFactory.getStatementConfig(config));
+        return await this.dbDriver.runDml(generateUpdate);
+    }
+
+    private async addUpdateFieldValues<T extends R>(table: Table<T>, record: any) {
+        for (let columnPropertyName in table.columns) {
+            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+            if (column.options?.updateValue)
+                record[columnPropertyName] = await column.options.updateValue(record);
+        }
+    }
+
+    async delete<T extends R>(table: Table<T>, query: Query<T>): Promise<number> {
+        if (!this.ignoreAuth)
+            this.auth.canDelete(table);
+        
+        const recordsToDelete = await this.query(table, query);
+        if (recordsToDelete.length == 0)
+            return 0;
+
+        const recordsToDeleteIds = recordsToDelete.map(record => record.id);
+        const deleteQb = new QueryBuilderFactory().getQueryBuilder(table);
+        deleteQb.condition({ field: 'id', operator: 'IN', value: recordsToDeleteIds as T[keyof T][] });
+        const generateDelete = (config: DbDriverStatementConfig) => new StatementFactory<T>().delete(table.name, deleteQb, this.statementConfigFactory.getStatementConfig(config));
+        await this.beforeDelete(table, recordsToDelete);
+        const deletedRowCount = await this.dbDriver.runDml(generateDelete);
+        await this.cascadeDeletions(table, recordsToDeleteIds);
+        return deletedRowCount;
+    }
+
+    private async beforeDelete(table: Table<any>, recordsToDelete: Record[]) {
+        for (let columnPropertyName in table.columns) {
+            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+            if (typeof column.beforeDelete !== 'undefined')
+                await column.beforeDelete(table, columnPropertyName, recordsToDelete);
+        }
+    }
+
+    private async cascadeDeletions(table: Table<any>, deletedRecordIds: string[]) {
+        if (table.cascadeDeleteReferences().length < 1)
+            return;
+
+        for (let cascadeDeleteReference of table.cascadeDeleteReferences()) {
+            const referenceTable = tableByName(cascadeDeleteReference.table);
+            const referenceColumnPropertyName = getColumnPropertyName(referenceTable, cascadeDeleteReference.referenceColumn);
+            this.logger.info(`Executing cascade delete for table: ${table.name}, referenceTable: ${referenceTable.name}, referenceColumnPropertyName: ${referenceColumnPropertyName}, deletedRecordIds: ${JSON.stringify(deletedRecordIds)}`);
+            const cascadeDeleteQb = new QueryBuilderFactory().getQueryBuilder(referenceTable);
+            cascadeDeleteQb.condition({ field: referenceColumnPropertyName as string, operator: 'IN', value: deletedRecordIds });
+            const deleteCount = await this.delete(referenceTable, cascadeDeleteQb);
+            this.logger.info(`Cascade deleted ${deleteCount} record${deleteCount == 1 ? '' : 's'}`);
+        }
+    }
+
+    async query<T extends R>(table: Table<T>, query: Query<T>): Promise<T[]> {
+        if (!this.ignoreAuth)
+            this.auth.canQuery(table);
+
+        const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
+        this.addColumnQueries(table, qb);
+        const generateQuery = (config: DbDriverStatementConfig) => qb.toSql(this.statementConfigFactory.getStatementConfig(config));
+        const serializedRecords = await this.dbDriver.runQuery(generateQuery);
+        const recordSearializer = new RecordSerializer(table);
+        return await Promise.all(serializedRecords.map(async (serializedRecord) => recordSearializer.deserialize(serializedRecord)));
+    }
+
+    async getRowCount<T extends R>(table: Table<T>, query?: Query<T>): Promise<number> {
+        if (!this.ignoreAuth)
+            this.auth.canQuery(table);
+
+        const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
+        qb.aggregate({ function: 'COUNT', resultProp: 'count' });
+        this.addColumnQueries(table, qb);
+        const generateQuery = (config: DbDriverStatementConfig) => qb.toSql(this.statementConfigFactory.getStatementConfig(config));
+        const result = await this.dbDriver.runQuery(generateQuery);
+        return result[0]['count'];
+    }
+
+    private async addColumnQueries<T extends R>(table: Table<T>, qb: QueryBuilder<T>) {
+        for (let columnPropertyName in table.columns) {
+            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+            if (column.options?.addToQuery)
+                column.options.addToQuery(qb);
+        }
+    }
+}

package/src/MigrationRunner.ts

@@ -0,0 +1,62 @@
+import { Moment, moment } from './opt/moment';
+import { getDb } from './Db';
+import { Table } from './Table';
+import { SourceRecordRepo } from './source/SourceRecordRepo';
+import { MigrationRunnerService, getMigrationRunnerService } from './services/MigrationRunnerService';
+import { Migration, MigrationTable } from './tables/MigrationTable';
+import { Service } from '@proteinjs/service';
+import { Logger } from '@proteinjs/util';
+
+export const getMigrationRunner = () => typeof self === 'undefined' ? new MigrationRunner() : getMigrationRunnerService() as MigrationRunner;
+
+export class MigrationRunner implements MigrationRunnerService {
+  private logger = new Logger(this.constructor.name);
+  public serviceMetadata: Service['serviceMetadata'] = {
+    doNotAwait: true,
+  };
+
+  async runMigration(id: string): Promise<void> {
+    const migrationTable: Table<Migration> = new MigrationTable();
+    const migration = new SourceRecordRepo().getSourceRecord<Migration>(migrationTable.name, id);
+    if (!migration)
+      throw new Error(`Unable to find migration source record for id: ${id}`);
+
+    const db = getDb();
+    migration.status = 'running';
+    migration.startTime = moment();
+    await db.update(migrationTable, migration);
+    this.logger.info(`Running migration (${migration.id}) ${migration.description}`);
+    try {
+      migration.output = await migration.run();
+      migration.status = 'success';
+    } catch (error: any) {
+      migration.failureMessage = error.message;
+      migration.failureStack = error.stack;
+      migration.status = 'failure';
+    } finally {
+      migration.endTime = moment();
+    }
+    migration.duration = this.duration(migration.startTime, migration.endTime);
+    await db.update(migrationTable, migration);
+    this.logger.info(`[${migration.status}] (${migration.duration}) Finished running migration (${migration.id}) ${migration.description}`);
+  }
+
+  private duration(start: Moment, end: Moment): string {
+    const duration = moment.duration(end.diff(start));
+    let parts: string[] = [];
+
+    const days = duration.days();
+    const hours = duration.hours();
+    const minutes = duration.minutes();
+    const seconds = duration.seconds();
+    const milliseconds = duration.milliseconds();
+
+    if (days > 0) parts.push(`${days} day${days > 1 ? 's' : ''}`);
+    if (hours > 0) parts.push(`${hours} hour${hours > 1 ? 's' : ''}`);
+    if (minutes > 0) parts.push(`${minutes} min${minutes > 1 ? 's' : ''}`);
+    if (seconds > 0) parts.push(`${seconds} sec${seconds > 1 ? 's' : ''}`);
+    if (days == 0 && hours == 0 && minutes == 0 && seconds == 0) parts.push(`${milliseconds} ms`);
+
+    return parts.join(' ');
+  }
+}

package/src/QueryBuilderFactory.ts

@@ -0,0 +1,18 @@
+import { Query } from './services/DbService';
+import { Table } from './Table';
+import { Record } from './Record';
+import { QueryBuilder } from '@proteinjs/db-query';
+
+export class QueryBuilderFactory {
+  getQueryBuilder<T extends Record>(table: Table<T>, query?: Query<T>): QueryBuilder<T> {
+    const qb = query ? 
+      query instanceof QueryBuilder ? 
+        query
+        :
+        QueryBuilder.fromObject<T>(query, table.name)
+      :
+      new QueryBuilder<T>(table.name)
+    ;
+    return qb;
+  }
+}

package/src/Record.ts

@@ -0,0 +1,113 @@
+import { DateTimeColumn, UuidColumn } from './Columns';
+import { Column, Table, Columns } from './Table';
+import { moment } from './opt/moment';
+
+export interface Record {
+	id: string;
+	created: moment.Moment;
+	updated: moment.Moment;
+}
+
+const recordColumns: Columns<Record> = {
+  id: new UuidColumn('id', { ui: { hidden: true } }),
+  created: new DateTimeColumn('created', { 
+    defaultValue: async () => moment(),
+  }),
+  updated: new DateTimeColumn('updated', { 
+    defaultValue: async () => moment(), 
+    updateValue: async () => moment(),
+  }),
+}
+
+/**
+ * Wrapper function to add default Record columns to your table's columns (should always use).
+ * 
+ * Note: using this requires an explicit dependency on moment@2.29.4 in your package (since transient dependencies are brittle by typescript's standards)
+ * 
+ * @param columns your columns
+ * @returns recordColumns & your columns
+ */
+export function withRecordColumns<T extends Record>(columns: Columns<Omit<T, keyof Record>>): Columns<Record> & Columns<Omit<T, keyof Record>> {
+  return Object.assign(Object.assign({}, recordColumns), columns);
+}
+
+export type SerializedRecord = { [columnName: string]: any }
+
+export class RecordSerializer<T extends Record> {
+  private table: Table<T>;
+  
+	constructor(table: Table<T>) {
+    this.table = table;
+  }
+
+  async serialize(record: any): Promise<SerializedRecord> {
+    const serialized: any = {};
+    const fieldSerializer = new FieldSerializer(this.table);
+    for (let fieldPropertyName in record) {
+      if (typeof record[fieldPropertyName] === 'function')
+        continue;
+      
+      const fieldValue = await record[fieldPropertyName];
+      const { columnName, serializedFieldValue } = await fieldSerializer.serialize(fieldPropertyName, fieldValue);
+      serialized[columnName] = serializedFieldValue;
+    }
+    return serialized;
+  }
+
+  async deserialize(serializedRecord: SerializedRecord): Promise<T> {
+    const deserialized: any = {};
+    const fieldSerializer = new FieldSerializer(this.table);
+    for (let columnName in serializedRecord) {
+      const serializedFieldValue = serializedRecord[columnName];
+      const { fieldPropertyName, fieldValue } = await fieldSerializer.deserialize(columnName, serializedFieldValue);
+      deserialized[fieldPropertyName] = fieldValue;
+    }
+    return deserialized;
+  }
+}
+
+export class FieldSerializer<T extends Record> {
+  constructor(
+    private table: Table<T>
+  ){}
+
+  async serialize(fieldPropertyName: string, fieldValue: any) {
+    const columns: {[prop: string]: Column<any, any>} = this.table.columns;
+    const column = columns[fieldPropertyName];
+    if (!column)
+      throw new Error(`[FieldSerializer.serialize] (${this.table.name}) no column matches fieldPropertyName: ${fieldPropertyName}`);
+
+    let serializedFieldValue = fieldValue;
+    if (column.serialize)
+      serializedFieldValue = await column.serialize(fieldValue);
+
+    return { columnName: column.name, serializedFieldValue };
+  }
+
+  async deserialize(columnName: string, serializedFieldValue: any) {
+    const columns: {[prop: string]: Column<any, any>} = this.table.columns;
+    let fieldPropertyName = columnName;
+    let column = columns[columnName]; // the scenario that the column name is the same as the property name
+    if (!column) {
+      for (let columnPropertyName in columns) {
+        const checkColumn = (this.table.columns as any)[columnPropertyName];
+        if (checkColumn && columnName == checkColumn.name) {
+          fieldPropertyName = columnPropertyName;
+          column = checkColumn;
+          break;
+        }
+      }
+    }
+
+    if (!column) {
+      // this is the case where a column exists in the db that is no longer defined in Table.columns
+      return { fieldPropertyName, fieldValue: undefined };
+    }
+
+    let fieldValue = serializedFieldValue
+    if (column.deserialize)
+      fieldValue = await column.deserialize(serializedFieldValue);
+
+    return { fieldPropertyName, fieldValue };
+  }
+}

package/src/RecordIterator.ts

@@ -0,0 +1,44 @@
+import { Db, getDb } from './Db';
+import { Table } from './Table';
+import { Record } from './Record';
+import { Query } from './services/DbService';
+import { QueryBuilderFactory } from './QueryBuilderFactory';
+import { QueryBuilder } from '@proteinjs/db-query';
+
+export class RecordIterator<T extends Record> implements AsyncIterable<T> {
+  private db: Db;
+  private table: Table<T>;
+  private query: QueryBuilder<T>;
+  private pageSize: number;
+  private currentPage: number;
+
+  constructor(table: Table<T>, query: Query<T>, pageSize: number = 10) {
+    this.db = getDb();
+    this.table = table;
+    this.query = new QueryBuilderFactory().getQueryBuilder(table, query);
+    this.pageSize = pageSize;
+    this.currentPage = 0;
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<T> {
+    while (true) {
+      const pagination = { start: this.currentPage * this.pageSize, end: (this.currentPage + 1) * this.pageSize - 1 };
+      this.query.paginate(pagination);
+      const results = await this.db.query(this.table, this.query);
+
+      if (results.length === 0) {
+        return;
+      }
+
+      for (const item of results) {
+        yield item;
+      }
+
+      if (results.length < this.pageSize) {
+        return;
+      }
+
+      this.currentPage++;
+    }
+  }
+}

package/src/StatementConfigFactory.ts

@@ -0,0 +1,36 @@
+import { StatementConfig } from '@proteinjs/db-query';
+import { Table, tableByName } from './Table';
+import { DbDriverStatementConfig } from './Db';
+
+export class StatementConfigFactory {
+  private dbName: string;
+  private getTable: (tableName: string) => Table<any>;
+
+  constructor(
+    dbName: string,
+    getTable?: (tableName: string) => Table<any>
+  ) {
+    this.dbName = dbName;
+    this.getTable = getTable ? getTable : tableByName;
+  }
+
+  getStatementConfig(config: DbDriverStatementConfig): StatementConfig {
+    return {
+        dbName: config.prefixTablesWithDb ? this.dbName : undefined,
+        resolveFieldName: this.getResolveFieldName(),
+        useParams: config.useParams,
+        useNamedParams: config.useNamedParams
+    };
+  }
+
+  private getResolveFieldName() {
+      return (tableName: string, propertyName: string): string => {
+        const table = this.getTable(tableName);
+        const column = table.columns[propertyName];
+        if (!column)
+          throw new Error(`(${table.name}) Column does not exist for property: ${propertyName}`);
+
+        return column.name;
+      }
+  }
+}

package/src/Table.ts

@@ -0,0 +1,124 @@
+import { Loadable, SourceRepository } from '@proteinjs/reflection';
+import { CustomSerializableObject } from '@proteinjs/serializer';
+import { Record } from './Record';
+import { TableSerializerId } from './serializers/TableSerializer';
+import { QueryBuilder } from '@proteinjs/db-query';
+import { Identity, TableOperationsAuth } from './auth/TableAuth';
+
+export const getTables = <T extends Record = any>() => SourceRepository.get().objects<Table<T>>('@proteinjs/db/Table');
+
+export const tableByName = (name: string) => {
+	const tables = getTables();
+	for (let table of tables) {
+		if (table.name == name)
+			return table;
+	}
+
+	throw new Error(`Unable to find table: ${name}`);
+}
+
+export const getColumnPropertyName = (table: Table<any>, columnName: string) => {
+	for (let columnPropertyName in table.columns) {
+		const column = table.columns[columnPropertyName];
+		if (column.name == columnName)
+			return columnPropertyName;
+	}
+
+	return null;
+}
+
+export const getColumnByName = (table: Table<any>, columnName: string) => {
+	for (let columnPropertyName in table.columns) {
+		const column = table.columns[columnPropertyName];
+		if (column.name == columnName)
+			return column;
+	}
+
+	return null;
+}
+
+/**
+ * primary key is `id`
+ */
+export abstract class Table<T extends Record> implements Loadable, CustomSerializableObject {
+	public __serializerId = TableSerializerId;
+	abstract name: string;
+	abstract columns: Columns<T>;
+	public indexes: { columns: (keyof T)[], name?: string }[] = [];
+	/** When records are deleted, delete records having references pointing to deleted records */
+	public cascadeDeleteReferences: () => { table: string, referenceColumn: string }[] = () => [];
+	/** 
+	 * Options for configuring SourceRecords
+	 * @param doNotDeleteSourceRecordsFromDb if true, the SourceRecordLoader will not delete source records from the db if they no longer exist on the file system
+	 */
+	public sourceRecordOptions: SourceRecordOptions = { 
+		doNotDeleteSourceRecordsFromDb: false,
+	};
+	public auth?: {
+		db?: TableOperationsAuth,
+		service?: TableOperationsAuth,
+		ui?: {
+			recordTable?: Identity,
+			recordForm?: Identity,
+		},
+	};
+}
+
+type ExcludeFunctions<T> = {
+  [P in keyof T as T[P] extends Function ? never : P]: T[P]
+}
+
+type RequiredProps<T> = {
+  [P in keyof ExcludeFunctions<T>]: ExcludeFunctions<T>[P] extends undefined ? never : P
+}[keyof ExcludeFunctions<T>]
+
+type OptionalProps<T> = {
+  [P in keyof ExcludeFunctions<T>]: ExcludeFunctions<T>[P] extends undefined ? P : never
+}[keyof ExcludeFunctions<T>]
+
+export type Columns<T> = {
+	[P in RequiredProps<T>]: Column<T[P], any>
+} & {
+	[P in OptionalProps<T>]?: Column<T[P] | undefined, any>
+}
+
+export type Column<T, Serialized> = {
+	name: string,
+	/**
+	 * Use to rename column, will find column with `oldName` and change it to `name`.
+	 * 
+	 * Note: after name change has happened in prod, oldName can be removed.
+	 */
+	oldName?: string,
+	options?: ColumnOptions,
+	serialize?: (fieldValue: T|undefined) => Promise<Serialized|undefined>,
+	deserialize?: (serializedFieldValue: Serialized) => Promise<T|void>,
+	beforeDelete?: (table: Table<any>, columnPropertyName: string, records: any[]) => Promise<void>,
+}
+
+export type ColumnOptions = {
+	unique?: { unique: boolean, indexName?: string },
+	/**
+	 * The column in the reference table `table` is the primary key of the table (`id` unless otherwise specified in the Table definition)
+	 * 
+	 * Note: use a migration to drop or change an existing foreign key
+	 */
+	references?: { table: string },
+	nullable?: boolean,
+	/** Value stored on insert */
+	defaultValue?: (insertObj: any) => Promise<any>,
+	/** Value stored on update */
+	updateValue?: (updateObj: any) => Promise<any>,
+	/** Add conditions to query; called on every query of this table */
+	addToQuery?: (qb: QueryBuilder) => Promise<void>,
+	ui?: {
+		hidden?: boolean,
+	},
+}
+
+export type SourceRecordOptions = { 
+	doNotDeleteSourceRecordsFromDb?: boolean,
+	ui?: {
+		hideColumns?: boolean,
+	},
+}

package/src/auth/TableAuth.ts

@@ -0,0 +1,60 @@
+import { UserAuth } from '@proteinjs/user-auth'
+import { Table } from '../Table'
+
+/**
+ * @public all users, including guests (do not need to be logged in), do not need any roles
+ * @authenticated - users need to be logged in, do not need any roles
+ * @roles string[] - authenticated users, having at least one of these roles
+ */
+export type Identity = 'public'|'authenticated'|string[]
+
+/**
+ * These Identities can perform these operations on this table.
+ * If omitted, defaults to requiring the 'admin' role (default deny)
+ */
+export type TableOperationsAuth = {
+	all?: Identity,
+	query?: Identity,
+	insert?: Identity,
+	update?: Identity,
+	delete?: Identity,
+}
+
+/**
+ * Util to check which table operations a user can perform
+ */
+export class TableAuth {
+  private canAccess(table: Table<any>, api: 'db'|'service', operation: 'query'|'insert'|'update'|'delete'): boolean {
+    const tableAuth = table.auth ? table.auth[api] : undefined;
+    if (!tableAuth || Object.keys(tableAuth).length == 0)
+      return UserAuth.hasRole('admin');
+
+    return tableAuth.all === 'public' 
+      || tableAuth[operation] === 'public'
+      || (tableAuth.all === 'authenticated' && UserAuth.isLoggedIn())
+      || (tableAuth[operation] === 'authenticated' && UserAuth.isLoggedIn())
+      || (Array.isArray(tableAuth.all) && UserAuth.hasRoles(tableAuth.all, 'at least one'))
+      || (Array.isArray(tableAuth[operation]) && UserAuth.hasRoles(tableAuth[operation] as string[], 'at least one'))
+    ;
+  }
+
+  canQuery(table: Table<any>, api: 'db'|'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'query'))
+      throw new Error(`User is not authorized to query table: ${table.name}`);
+  }
+
+  canInsert(table: Table<any>, api: 'db'|'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'insert'))
+      throw new Error(`User is not authorized to insert records into table: ${table.name}`);
+  }
+
+  canUpdate(table: Table<any>, api: 'db'|'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'update'))
+      throw new Error(`User is not authorized to update records in table: ${table.name}`);
+  }
+
+  canDelete(table: Table<any>, api: 'db'|'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'query'))
+      throw new Error(`User is not authorized to delete records from table: ${table.name}`);
+  }
+}