@digitraffic/common 2022.10.25-1 → 2022.10.28-2

package/src/aws/runtime/secrets/dbsecret.ts

@@ -0,0 +1,116 @@
+import {withSecret, withSecretAndPrefix} from "./secret";
+
+export type DbSecret = {
+    readonly username: string
+    readonly password: string
+    readonly host: string
+    readonly ro_host: string
+};
+
+export enum RdsProxySecretKey {
+    username = "username", password = "password", proxy_host = "proxy_host", proxy_ro_host = "proxy_ro_host"
+}
+
+export enum RdsSecretKey {
+    username = "username", password = "password", host = "host", ro_host = "ro_host"
+}
+
+export type RdsProxySecret = Record<RdsProxySecretKey, string>;
+export type RdsSecret = Record<RdsSecretKey, string>;
+
+export enum DatabaseEnvironmentKeys {
+    DB_USER = "DB_USER",
+    DB_PASS = "DB_PASS",
+    DB_URI = "DB_URI",
+    DB_RO_URI = "DB_RO_URI",
+    DB_APPLICATION = "DB_APPLICATION",
+}
+
+function setDbSecret(secret: DbSecret) {
+    process.env[DatabaseEnvironmentKeys.DB_USER] = secret.username;
+    process.env[DatabaseEnvironmentKeys.DB_PASS] = secret.password;
+    process.env[DatabaseEnvironmentKeys.DB_URI] = secret.host;
+    process.env[DatabaseEnvironmentKeys.DB_RO_URI] = secret.ro_host;
+}
+
+// cached at Lambda container level
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let cachedSecret: any;
+
+const missingSecretErrorText = 'Missing or empty secretId';
+
+/**
+ * You can give the following options for retrieving a secret:
+ *
+ * expectedKeys: the list of keys the secret must include.  If not, an error will be thrown.
+ * prefix: a prefix that's included in retrieved secret's keys.  Only keys begining with the prefix will be included.
+ * The secret that is passed to the given function will not include the prefix in it's keys.
+
+ */
+export type SecretOptions = {
+    readonly expectedKeys?: string[],
+    readonly prefix?: string
+}
+
+export type SecretToPromiseFunction<Secret, Response = void> = (secret: Secret) => Promise<Response> | void;
+export type SecretFunction<Secret, Response = void> = (secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions) => Promise<Response | void>;
+export type EmptySecretFunction<Response = void> = SecretFunction<DbSecret, Response>;
+
+/**
+ * Run the given function with secret retrieved from Secrets Manager.  Also injects database-credentials into environment.
+ *
+ * @deprecated use SecretHolder & ProxyHolder
+ * @see SecretOptions
+ *
+ * @param {string} secretId
+ * @param {function} fn
+ * @param {SecretOptions} options
+ */
+export async function withDbSecret<Secret, Response>(secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions): Promise<Response | void> {
+    if (!secretId) {
+        console.error(missingSecretErrorText);
+        return Promise.reject(missingSecretErrorText);
+    }
+
+    if (!cachedSecret) {
+        // if prefix is given, first set db values and then fetch secret
+        if (options?.prefix) {
+            // first set db values
+            await withSecret(secretId, (fetchedSecret: DbSecret) => {
+                setDbSecret(fetchedSecret);
+            });
+
+            // then actual secret
+            await withSecretAndPrefix(secretId, options.prefix, (fetchedSecret: Secret) => {
+                cachedSecret = fetchedSecret;
+            });
+        } else {
+            await withSecret(secretId, (fetchedSecret: DbSecret) => {
+                setDbSecret(fetchedSecret);
+                cachedSecret = fetchedSecret;
+            });
+        }
+    }
+    try {
+        if (options?.expectedKeys?.length) {
+            checkExpectedSecretKeys(options.expectedKeys, cachedSecret);
+        }
+        return fn(cachedSecret);
+    } catch (error) {
+        console.error('method=withDbSecret Caught an error, refreshing secret', error);
+        // try to refetch secret in case it has changed
+        await withSecret(secretId, (fetchedSecret: DbSecret) => {
+            setDbSecret(fetchedSecret);
+            cachedSecret = fetchedSecret;
+        });
+        return fn(cachedSecret);
+    }
+}
+
+export function checkExpectedSecretKeys<Secret>(keys: string[], secret: Secret) {
+    const missingKeys = keys.filter(key => !(key in secret));
+    if (missingKeys.length) {
+        console.error(`method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys}`);
+        throw new Error('Expected keys were not found');
+    }
+}

package/src/aws/runtime/secrets/proxy-holder.ts

@@ -0,0 +1,37 @@
+import { SecretHolder } from "./secret-holder";
+import {
+    DatabaseEnvironmentKeys,
+    RdsProxySecretKey,
+    RdsProxySecret,
+} from "./dbsecret";
+import { getEnvVariable } from "../../../utils/utils";
+
+const RDS_PROXY_SECRET_KEYS = Object.values(RdsProxySecretKey);
+
+/**
+ * Holds credentials for RDS Proxy access.
+ */
+export class ProxyHolder {
+    private readonly secretHolder;
+
+    constructor(secretId: string) {
+        this.secretHolder = new SecretHolder<RdsProxySecret>(
+            secretId,
+            "",
+            RDS_PROXY_SECRET_KEYS
+        );
+    }
+
+    static create() {
+        return new ProxyHolder(getEnvVariable("SECRET_ID"));
+    }
+
+    public async setCredentials() {
+        const secret = await this.secretHolder.get();
+
+        process.env[DatabaseEnvironmentKeys.DB_USER] = secret.username;
+        process.env[DatabaseEnvironmentKeys.DB_PASS] = secret.password;
+        process.env[DatabaseEnvironmentKeys.DB_URI] = secret.proxy_host;
+        process.env[DatabaseEnvironmentKeys.DB_RO_URI] = secret.proxy_ro_host;
+    }
+}

package/src/aws/runtime/secrets/rds-holder.ts

@@ -0,0 +1,33 @@
+import { SecretHolder } from "./secret-holder";
+import { DatabaseEnvironmentKeys, RdsSecret, RdsSecretKey } from "./dbsecret";
+import { getEnvVariable } from "../../../utils/utils";
+
+const RDS_SECRET_KEYS = Object.values(RdsSecretKey);
+
+/**
+ * Holds credentials for RDS access.
+ */
+export class RdsHolder {
+    private readonly secretHolder;
+
+    constructor(secretId: string) {
+        this.secretHolder = new SecretHolder<RdsSecret>(
+            secretId,
+            "",
+            RDS_SECRET_KEYS
+        );
+    }
+
+    static create() {
+        return new RdsHolder(getEnvVariable("SECRET_ID"));
+    }
+
+    public async setCredentials() {
+        const secret = await this.secretHolder.get();
+
+        process.env[DatabaseEnvironmentKeys.DB_USER] = secret.username;
+        process.env[DatabaseEnvironmentKeys.DB_PASS] = secret.password;
+        process.env[DatabaseEnvironmentKeys.DB_URI] = secret.host;
+        process.env[DatabaseEnvironmentKeys.DB_RO_URI] = secret.ro_host;
+    }
+}

package/src/aws/runtime/secrets/secret-holder.ts

@@ -0,0 +1,116 @@
+import { GenericSecret, getSecret } from "./secret";
+import {
+    checkExpectedSecretKeys,
+    DatabaseEnvironmentKeys,
+    DbSecret,
+} from "./dbsecret";
+import { getEnvVariable } from "../../../utils/utils";
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const NodeTtl = require("node-ttl");
+
+const DEFAULT_PREFIX = "";
+const DEFAULT_SECRET_KEY = "SECRET";
+const DEFAULT_CONFIGURATION = {
+    ttl: 5 * 60, // timeout secrets in 5 minutes
+};
+
+/**
+ * Utility class for getting secrets from Secret Manager.
+ * Supports prefix for secrets, checking of expected keys and ttl-configuration.
+ *
+ * By default, secrets are cached for 5 minutes and then reread from the Secrets Manager(This can be overridden with configuration).
+ *
+ * Supports setting the database environment paramaters from the secret too.
+ */
+export class SecretHolder<Secret> {
+    private readonly secretId: string;
+    private readonly prefix: string;
+    private readonly expectedKeys: string[];
+
+    private readonly secretCache;
+
+    constructor(
+        secretId: string,
+        prefix = "",
+        expectedKeys: string[] = [],
+        configuration = DEFAULT_CONFIGURATION
+    ) {
+        this.secretId = secretId;
+        this.prefix = prefix;
+        this.expectedKeys = expectedKeys;
+
+        this.secretCache = new NodeTtl(configuration);
+    }
+
+    private async initSecret() {
+        const secretValue = await getSecret<Secret>(this.secretId);
+
+        console.info("refreshing secret " + this.secretId);
+
+        this.secretCache.push(DEFAULT_SECRET_KEY, secretValue);
+    }
+
+    public static create<S>(
+        prefix = DEFAULT_PREFIX,
+        expectedKeys: string[] = []
+    ) {
+        return new SecretHolder<S>(
+            getEnvVariable("SECRET_ID"),
+            prefix,
+            expectedKeys
+        );
+    }
+
+    public async get(): Promise<Secret> {
+        const secret = await this.getSecret<Secret>();
+        const parsedSecret =
+            this.prefix === DEFAULT_PREFIX
+                ? secret
+                : this.parseSecret(
+                      secret as unknown as GenericSecret,
+                      `${this.prefix}.`
+                  );
+
+        if (this.expectedKeys.length > 0) {
+            checkExpectedSecretKeys(this.expectedKeys, parsedSecret);
+        }
+
+        return parsedSecret;
+    }
+
+    private parseSecret(secret: GenericSecret, prefix: string): Secret {
+        const parsed: GenericSecret = {};
+        const skip = prefix.length;
+
+        for (const key in secret) {
+            if (key.startsWith(prefix)) {
+                parsed[key.substring(skip)] = secret[key];
+            }
+        }
+
+        return parsed as unknown as Secret;
+    }
+
+    private async getSecret<S>(): Promise<S> {
+        const secret = this.secretCache.get(DEFAULT_SECRET_KEY);
+
+        if (!secret) {
+            await this.initSecret();
+        }
+
+        return secret || this.secretCache.get(DEFAULT_SECRET_KEY);
+    }
+
+    /**
+     * @deprecated Use ProxyHolder
+     */
+    public async setDatabaseCredentials() {
+        const secret = await this.getSecret<DbSecret>();
+
+        process.env[DatabaseEnvironmentKeys.DB_USER] = secret.username;
+        process.env[DatabaseEnvironmentKeys.DB_PASS] = secret.password;
+        process.env[DatabaseEnvironmentKeys.DB_URI] = secret.host;
+        process.env[DatabaseEnvironmentKeys.DB_RO_URI] = secret.ro_host;
+    }
+}

package/src/aws/runtime/secrets/secret.ts

@@ -0,0 +1,50 @@
+import {SecretsManager} from 'aws-sdk';
+import {SecretToPromiseFunction} from "./dbsecret";
+
+const smClient = new SecretsManager({
+    region: process.env.AWS_REGION,
+});
+
+export type GenericSecret = Record<string, string>;
+
+/**
+ @deprecated use SecretHolder & ProxyHolder
+ */
+export async function withSecret<Secret, Response>(secretId: string, fn: SecretToPromiseFunction<Secret, Response>): Promise<Response | void> {
+    return fn(await getSecret(secretId));
+}
+
+export async function getSecret<Secret>(secretId: string, prefix = ''): Promise<Secret> {
+    const secretObj = await smClient.getSecretValue({
+        SecretId: secretId,
+    }).promise();
+
+    if (!secretObj.SecretString) {
+        throw new Error('No secret found!');
+    }
+
+    const secret = JSON.parse(secretObj.SecretString);
+
+    if (prefix === '') {
+        return secret;
+    }
+
+    return parseSecret(secret, `${prefix}.`);
+}
+
+function parseSecret<Secret>(secret: GenericSecret, prefix: string): Secret {
+    const parsed: GenericSecret = {};
+    const skip = prefix.length;
+
+    for (const key in secret) {
+        if (key.startsWith(prefix)) {
+            parsed[key.substring(skip)] = secret[key];
+        }
+    }
+
+    return parsed as unknown as Secret;
+}
+
+export async function withSecretAndPrefix<Secret, Response>(secretId: string, prefix: string, fn: SecretToPromiseFunction<Secret, Response>): Promise<Response | void> {
+    return fn(await getSecret(secretId, prefix));
+}

package/src/aws/types/errors.ts

@@ -0,0 +1,14 @@
+// DEPRECATED, remove these!
+export const NOT_FOUND_MESSAGE = "NOT_FOUND";
+export const ERROR_MESSAGE = "ERROR";
+export const OK_MESSAGE = "OK";
+export const BAD_REQUEST_MESSAGE = "BAD REQUEST";
+
+export class ValidationError extends Error {
+    statusCode: number;
+
+    constructor(statusCode: number, body: string) {
+        super(body);
+        this.statusCode = statusCode;
+    }
+}

package/src/aws/types/lambda-response.ts

@@ -0,0 +1,43 @@
+export class LambdaResponse<T> {
+    readonly status: number;
+    readonly body: T;
+    readonly fileName?: string;
+
+    constructor(status: number, body: T, fileName?: string) {
+        this.status = status;
+        this.body = body;
+        this.fileName = fileName;
+    }
+
+    static ok<T>(body: T, fileName?: string) {
+        return this.create(200, body, fileName);
+    }
+
+    static okJson<T>(json: T, fileName?: string) {
+        return this.create(200, JSON.stringify(json, null, 2), fileName);
+    }
+
+    static badRequest(body: string) {
+        return this.create(400, body);
+    }
+
+    static notFound() {
+        return this.create(404, "Not found");
+    }
+
+    static internalError() {
+        return this.create(500, "Internal error");
+    }
+
+    static notImplemented() {
+        return this.create(501, "Not implemented");
+    }
+
+    static create<T>(
+        status: number,
+        body: T,
+        fileName?: string
+    ): Promise<LambdaResponse<T>> {
+        return Promise.resolve(new LambdaResponse(status, body, fileName));
+    }
+}

package/src/aws/types/mediatypes.ts

@@ -0,0 +1,11 @@
+// charset=UTF-8 is deprecated but mobile applications sometimes needs it
+export enum MediaType {
+    APPLICATION_JSON = "application/json;charset=UTF-8",
+    APPLICATION_XML = "application/xml",
+    APPLICATION_GEOJSON = "application/geo+json;charset=UTF-8",
+    IMAGE_SVG = "image/svg+xml",
+    IMAGE_JPEG = "image/jpeg",
+    TEXT_PLAIN = "text/plain",
+    TEXT_HTML = "text/html",
+    TEXT_CSV = "text/csv",
+}

package/src/aws/types/model-with-reference.ts

@@ -0,0 +1,8 @@
+import {Model} from "aws-cdk-lib/aws-apigateway";
+
+/**
+ * Model object with a reference to an API Gateway model object.
+ */
+export interface ModelWithReference extends Model {
+    modelReference: string;
+}

package/src/aws/types/proxytypes.ts

@@ -0,0 +1,27 @@
+/**
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
+ *
+ * Not fully described, extend if necessary.
+ */
+export type ProxyLambdaResponse = {
+    readonly statusCode: number
+    readonly body: string
+    readonly headers?: Record<string, string>
+    readonly multiValueHeaders?: Record<string, string[]>
+}
+
+/**
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
+ *
+ * Not fully described, extend if necessary.
+ */
+export type ProxyLambdaRequest = {
+    readonly resource: string
+    readonly path: string
+    readonly httpMethod: string
+    readonly headers: Record<string, string>
+    readonly multiValueHeaders: Record<string, string[]>
+    readonly queryStringParameters: Record<string, string>
+    readonly multiValueQueryStringParameters: Record<string, string[]>
+    readonly body?: string
+}

package/src/aws/types/tags.ts

@@ -0,0 +1,3 @@
+// DEPRECATED! This must be replaced with new application specific tags
+export const BETA_TAGS = ['Beta'];
+export const DATA_V1_TAGS = ['Data v1'];

package/src/database/cached.ts

@@ -0,0 +1,35 @@
+import {PreparedStatement} from "pg-promise";
+import {DTDatabase, DTTransaction} from "./database";
+
+const SQL_UPDATE_CACHE_VALUE =
+    `insert into cached_json(cache_id, content, last_updated)
+    values ($1, $2, now())
+    on conflict(cache_id) do
+    update set content = $2, last_updated = now()`;
+
+const SQL_GET_CACHE_VALUE =
+    `select content, last_updated from cached_json
+    where cache_id = $1`;
+
+const PS_UPDATE_CACHE_VALUE = new PreparedStatement({
+    name: 'update-cache-value',
+    text: SQL_UPDATE_CACHE_VALUE,
+});
+
+const PS_GET_CACHE_VALUE = new PreparedStatement({
+    name: 'get-cache-value',
+    text: SQL_GET_CACHE_VALUE,
+});
+
+export enum JSON_CACHE_KEY {
+    NAUTICAL_WARNINGS_ACTIVE = 'nautical-warnings-active',
+    NAUTICAL_WARNINGS_ARCHIVED = 'nautical-warnings-archived'
+}
+
+export function updateCachedJson<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY, value: T): Promise<null> {
+    return db.none(PS_UPDATE_CACHE_VALUE, [cacheKey, value]);
+}
+
+export function getJsonFromCache<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY): Promise<T | null> {
+    return db.oneOrNone(PS_GET_CACHE_VALUE, [cacheKey]).then(value => value?.content ?? null);
+}

package/src/database/database.ts

@@ -0,0 +1,96 @@
+import { IDatabase, ITask } from "pg-promise";
+import { DatabaseEnvironmentKeys } from "../aws/runtime/secrets/dbsecret";
+import { getEnvVariable, getEnvVariableSafe } from "../utils/utils";
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pgp = require("pg-promise")();
+
+// convert numeric types to number instead of string
+pgp.pg.types.setTypeParser(pgp.pg.types.builtins.INT8, (value: string) => {
+    return parseInt(value);
+});
+
+pgp.pg.types.setTypeParser(pgp.pg.types.builtins.FLOAT8, (value: string) => {
+    return parseFloat(value);
+});
+
+pgp.pg.types.setTypeParser(pgp.pg.types.builtins.NUMERIC, (value: string) => {
+    return parseFloat(value);
+});
+
+export type DTDatabase = IDatabase<unknown>;
+
+export type DTTransaction = ITask<unknown>;
+
+/**
+ * Creates a non-pooling database connection primarily used by Lambdas.
+ *
+ * Note! Using this method opens a new RDS connection on every invocation. It is advised to
+ * use RDS proxy to pool connections transparently.
+ * https://docs.amazonaws.cn/en_us/AmazonRDS/latest/AuroraUserGuide/rds-proxy.html
+ * @param username Username
+ * @param password Password
+ * @param applicationName name of application
+ * @param url Connection URL
+ * @param options pg-promise options
+ */
+export function initDbConnection(
+    username: string,
+    password: string,
+    applicationName: string,
+    url: string,
+    options?: object
+): DTDatabase {
+    const finalUrl = `postgresql://${username}:${password}@${url}?application_name=${applicationName}`;
+
+    return pgp(finalUrl, options);
+}
+
+export function inTransaction<T>(
+    fn: (db: DTTransaction) => Promise<T>
+): Promise<T> {
+    return inDatabase((db) => db.tx((t: DTTransaction) => fn(t)));
+}
+
+export function inDatabase<T>(fn: (db: DTDatabase) => Promise<T>): Promise<T> {
+    return doInDatabase(false, fn);
+}
+
+export function inDatabaseReadonly<T>(
+    fn: (db: DTDatabase) => Promise<T>
+): Promise<T> {
+    return doInDatabase(true, fn);
+}
+
+async function doInDatabase<T>(
+    readonly: boolean,
+    fn: (db: DTDatabase) => Promise<T>
+): Promise<T> {
+    const db_application = getEnvVariableSafe(
+        DatabaseEnvironmentKeys.DB_APPLICATION
+    );
+    const db_ro_uri = getEnvVariableSafe(DatabaseEnvironmentKeys.DB_RO_URI);
+    const db_uri =
+        db_ro_uri.result === "ok"
+            ? db_ro_uri.value
+            : getEnvVariable(DatabaseEnvironmentKeys.DB_URI);
+    const db = initDbConnection(
+        getEnvVariable(DatabaseEnvironmentKeys.DB_USER),
+        getEnvVariable(DatabaseEnvironmentKeys.DB_PASS),
+        db_application.result === "ok"
+            ? db_application.value
+            : "unknown-cdk-application",
+        db_uri
+    );
+    try {
+        // deallocate all prepared statements to allow for connection pooling
+        // DISCARD instead of DEALLOCATE as it didn't always clean all prepared statements
+        await db.none("DISCARD ALL");
+        return await fn(db);
+    } catch (e) {
+        console.error("Error in db:", e);
+        throw e;
+    } finally {
+        db.$pool.end();
+    }
+}

package/src/database/last-updated.ts

@@ -0,0 +1,59 @@
+import {DTDatabase, DTTransaction} from "./database";
+
+export enum DataType {
+    VS_DATEX2="VS_DATEX2",
+    COUNTING_SITES_DATA="COUNTING_SITES_DATA",
+    COUNTING_SITES_METADATA="COUNTING_SITES_METADATA",
+    COUNTING_SITES_METADATA_CHECK="COUNTING_SITES_METADATA_CHECK",
+    MAINTENANCE_TRACKING_DATA_CHECKED="MAINTENANCE_TRACKING_DATA_CHECKED",
+    PERMIT_DATA="PERMIT_DATA",
+    PERMIT_DATA_CHECK="PERMIT_DATA_CHECK",
+}
+
+const UNSET_SUBTYPE = '-';
+
+type UpdatedTimestamp = {
+    updated: Date
+} | null;
+
+export function getLastUpdated(db: DTDatabase, datatype: DataType): Promise<Date | null> {
+    return db.oneOrNone("select updated from data_updated where data_type=$(datatype) and subtype=$(subtype)", {
+        datatype: datatype, subtype: UNSET_SUBTYPE,
+    }, (x: UpdatedTimestamp) => x?.updated || null);
+}
+
+export function getLastUpdatedWithSubtype(db: DTDatabase, datatype: DataType, subtype: string): Promise<Date | null> {
+    return db.oneOrNone("SELECT updated FROM data_updated WHERE data_type=$(datatype) AND subtype=$(subtype)", {
+        datatype: datatype, subtype: subtype,
+    }, (x: UpdatedTimestamp) => x?.updated || null);
+}
+
+export function updateLastUpdated(db: DTDatabase | DTTransaction, datatype: DataType, updated: Date): Promise<null> {
+    return db.none(`insert into data_updated(id, data_type, updated)
+ values(nextval('seq_data_updated'), $(datatype), $(updated))
+ on conflict (data_type, subtype)
+ do update set updated = $(updated)`,
+    { updated, datatype });
+}
+
+export function updateLastUpdatedWithSubtype(db: DTDatabase | DTTransaction, datatype: DataType, subtype: string, updated: Date): Promise<null> {
+    return db.none(`insert into data_updated(id, data_type, subtype, updated)
+ values(nextval('seq_data_updated'), $(datatype), $(subtype), $(updated))
+ on conflict (data_type, subtype)
+ do update set updated = $(updated)`,
+    { updated, subtype, datatype });
+}
+
+export function getUpdatedTimestamp(db: DTDatabase, datatype: string): Promise<Date | null> {
+    return db.oneOrNone("select updated_time as updated from updated_timestamp where updated_name=$(datatype)", {
+        datatype: datatype,
+    }, (x: UpdatedTimestamp) => x?.updated || null);
+}
+
+export function updateUpdatedTimestamp(db: DTDatabase | DTTransaction, datatype: string, date: Date, by = ''): Promise<null> {
+    return db.none(`insert into updated_timestamp(updated_name, updated_time, updated_by)
+values($(datatype), $(date), $(by))
+on conflict (updated_name)
+do update set updated_time = $(date), updated_by = $(by)`,
+    { date, datatype, by });
+}

package/src/database/models.ts

@@ -0,0 +1,7 @@
+export interface Countable {
+    count: number;
+}
+
+export interface Identifiable<T> {
+    id: T;
+}