@loomcore/api 0.0.1

package/dist/utils/api.utils.js

@@ -0,0 +1,60 @@
+import { QueryOptions } from '@loomcore/common/models';
+function apiResponse(response, status, options = {}, modelSpec, publicSchema) {
+    const success = status >= 200 && status < 300;
+    let apiResponse;
+    if (modelSpec && options.data) {
+        if (Array.isArray(options.data)) {
+            options.data = options.data.map((item) => modelSpec.encode(item, publicSchema));
+        }
+        else if (typeof options.data === 'object' && options.data !== null && 'entities' in options.data && Array.isArray(options.data.entities)) {
+            const pagedResult = options.data;
+            pagedResult.entities = pagedResult.entities.map((item) => modelSpec.encode(item, publicSchema));
+            options.data = pagedResult;
+        }
+        else {
+            options.data = modelSpec.encode(options.data, publicSchema);
+        }
+    }
+    if (success) {
+        apiResponse = {
+            success,
+            status,
+            data: options?.data,
+            messages: options?.messages,
+            errors: options.errors,
+        };
+    }
+    else {
+        apiResponse = {
+            success,
+            status: status,
+            errors: options.errors,
+        };
+    }
+    return response.status(status).json(apiResponse);
+}
+function getQueryOptionsFromRequest(request) {
+    const queryOptions = {
+        orderBy: request.query.orderBy,
+        sortDirection: request.query.sortDirection,
+        page: request.query.page ? parseInt(request.query.page) : 1,
+        pageSize: request.query.pageSize ? parseInt(request.query.pageSize) : 100,
+        filters: request.query.filters
+    };
+    return new QueryOptions(queryOptions);
+}
+function getPagedResult(entities, totalRows, queryOptions) {
+    const pagedResult = {
+        entities,
+        total: totalRows,
+        page: queryOptions.page,
+        pageSize: queryOptions.pageSize,
+        totalPages: Math.ceil(totalRows / queryOptions.pageSize),
+    };
+    return pagedResult;
+}
+export const apiUtils = {
+    apiResponse,
+    getQueryOptionsFromRequest,
+    getPagedResult,
+};

package/dist/utils/conversion.utils.d.ts

@@ -0,0 +1,5 @@
+declare function convertISOStringDateTimesToJSDates(objectToConvert: any): void;
+export declare const conversionUtils: {
+    convertISOStringDateTimesToJSDates: typeof convertISOStringDateTimesToJSDates;
+};
+export {};

package/dist/utils/conversion.utils.js

@@ -0,0 +1,14 @@
+function convertISOStringDateTimesToJSDates(objectToConvert) {
+    var iso8601RegEx = /((((\d{4})(-((0[1-9])|(1[012])))(-((0[1-9])|([12]\d)|(3[01]))))(T((([01]\d)|(2[0123]))((:([012345]\d))((:([012345]\d))(\.(\d+))?)?)?)(Z|([\+\-](([01]\d)|(2[0123]))(:([012345]\d))?)))?)|(((\d{4})((0[1-9])|(1[012]))((0[1-9])|([12]\d)|(3[01])))(T((([01]\d)|(2[0123]))(([012345]\d)(([012345]\d)(\d+)?)?)?)(Z|([\+\-](([01]\d)|(2[0123]))([012345]\d)?)))?))/;
+    for (var property in objectToConvert) {
+        if (objectToConvert.hasOwnProperty(property)) {
+            if (iso8601RegEx.test(objectToConvert[property])) {
+                var date = new Date(objectToConvert[property]);
+                objectToConvert[property] = date;
+            }
+        }
+    }
+}
+export const conversionUtils = {
+    convertISOStringDateTimesToJSDates
+};

package/dist/utils/db.utils.d.ts

@@ -0,0 +1,27 @@
+import { ObjectId } from 'mongodb';
+import { TSchema } from '@sinclair/typebox';
+import { IQueryOptions, Filter } from '@loomcore/common/models';
+export declare const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS: string[];
+declare function convertObjectIdsToStrings<T>(entity: T, schema?: TSchema): T;
+declare function convertStringsToObjectIds(entity: any, schema: TSchema): any;
+declare function convertStringToObjectId(value: any): ObjectId | any;
+declare function buildMongoMatchFromQueryOptions(queryOptions: IQueryOptions): {
+    $match: any;
+};
+declare function buildSQLWhereClauseFromQueryOptions(queryOptions: IQueryOptions, columnAliasMap: {
+    [key: string]: string;
+}): string;
+declare function addKeyValueToWhereClause(whereClause: string, key: string, value: Filter, tableAlias?: string): string;
+declare function appendToWhereClause(whereClause: string, condition: string): string;
+declare function formatValue(value: string | number | boolean | Date, isLikeOperator?: boolean): string;
+export declare const dbUtils: {
+    buildMongoMatchFromQueryOptions: typeof buildMongoMatchFromQueryOptions;
+    buildSQLWhereClauseFromQueryOptions: typeof buildSQLWhereClauseFromQueryOptions;
+    addKeyValueToWhereClause: typeof addKeyValueToWhereClause;
+    appendToWhereClause: typeof appendToWhereClause;
+    formatValue: typeof formatValue;
+    convertStringToObjectId: typeof convertStringToObjectId;
+    convertStringsToObjectIds: typeof convertStringsToObjectIds;
+    convertObjectIdsToStrings: typeof convertObjectIdsToStrings;
+};
+export {};

package/dist/utils/db.utils.js

@@ -0,0 +1,273 @@
+import { ObjectId } from 'mongodb';
+import _ from 'lodash';
+import { entityUtils } from '@loomcore/common/utils';
+import { stringUtils } from './string.utils.js';
+export const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS = ['_orgId'];
+function convertObjectIdsToStrings(entity, schema) {
+    if (!entity)
+        return entity;
+    const clone = _.cloneDeep(entity);
+    if (!schema) {
+        if (clone._id && clone._id instanceof ObjectId) {
+            clone._id = clone._id.toString();
+        }
+        return clone;
+    }
+    const processEntity = (obj, subSchema, path = []) => {
+        if (!obj || typeof obj !== 'object')
+            return;
+        if (subSchema.allOf && Array.isArray(subSchema.allOf)) {
+            for (const nestedSchema of subSchema.allOf) {
+                processEntity(obj, nestedSchema, path);
+            }
+            return;
+        }
+        if (subSchema.type === 'object' && subSchema.properties) {
+            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
+                if (!propSchema || typeof propSchema !== 'object')
+                    continue;
+                const typedPropSchema = propSchema;
+                const fullPath = [...path, key];
+                if (typedPropSchema.format === 'objectid') {
+                    if (path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
+                        continue;
+                    }
+                    if (obj[key] instanceof ObjectId) {
+                        obj[key] = obj[key].toString();
+                    }
+                }
+                else if (typedPropSchema.type === 'object' && obj[key]) {
+                    processEntity(obj[key], typedPropSchema, fullPath);
+                }
+                else if (typedPropSchema.type === 'array' && Array.isArray(obj[key])) {
+                    const items = typedPropSchema.items;
+                    if (items) {
+                        for (let i = 0; i < obj[key].length; i++) {
+                            if (items.format === 'objectid') {
+                                if (path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
+                                    continue;
+                                }
+                                if (obj[key][i] instanceof ObjectId) {
+                                    obj[key][i] = obj[key][i].toString();
+                                }
+                            }
+                            else if (items.type === 'object') {
+                                processEntity(obj[key][i], items, [...fullPath, i.toString()]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    processEntity(clone, schema);
+    return clone;
+}
+function convertStringsToObjectIds(entity, schema) {
+    if (!entity)
+        return entity;
+    const clone = _.cloneDeep(entity);
+    const processEntity = (obj, subSchema, path = []) => {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        if (obj instanceof Date) {
+            return obj;
+        }
+        if (subSchema.allOf && Array.isArray(subSchema.allOf)) {
+            let result = { ...obj };
+            for (const nestedSchema of subSchema.allOf) {
+                result = processEntity(result, nestedSchema, path);
+            }
+            return result;
+        }
+        if (Array.isArray(obj)) {
+            const items = subSchema.items;
+            if (!items)
+                return obj;
+            if (items.format === 'objectid') {
+                if (path.length === 1 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(path[0])) {
+                    return obj;
+                }
+                return obj.map(item => {
+                    if (typeof item === 'string' && entityUtils.isValidObjectId(item)) {
+                        return new ObjectId(item);
+                    }
+                    return item;
+                });
+            }
+            if (items.type === 'object') {
+                return obj.map((item, index) => processEntity(item, items, [...path, index.toString()]));
+            }
+            return obj;
+        }
+        const result = { ...obj };
+        if (subSchema.type === 'object' && subSchema.properties) {
+            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
+                if (!propSchema || typeof propSchema !== 'object' || result[key] === null || result[key] === undefined) {
+                    continue;
+                }
+                const typedPropSchema = propSchema;
+                const fullPath = [...path, key];
+                const value = result[key];
+                const isObjectIdField = typedPropSchema.format === 'objectid';
+                if (isObjectIdField && path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
+                    continue;
+                }
+                if (isObjectIdField && typeof value === 'string' && entityUtils.isValidObjectId(value)) {
+                    result[key] = new ObjectId(value);
+                }
+                else if (typedPropSchema.type === 'array' && Array.isArray(value)) {
+                    result[key] = processEntity(value, typedPropSchema, fullPath);
+                }
+                else if (typedPropSchema.type === 'object' && typeof value === 'object' && !Array.isArray(value)) {
+                    result[key] = processEntity(value, typedPropSchema, fullPath);
+                }
+            }
+        }
+        return result;
+    };
+    return processEntity(clone, schema);
+}
+function convertStringToObjectId(value) {
+    if (value instanceof ObjectId) {
+        return value;
+    }
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === 'string' && entityUtils.isValidObjectId(value)) {
+        try {
+            return new ObjectId(value);
+        }
+        catch (error) {
+            console.warn(`Failed to convert string "${value}" to ObjectId:`, error);
+            return value;
+        }
+    }
+    return value;
+}
+function buildMongoMatchFromQueryOptions(queryOptions) {
+    const filters = queryOptions.filters || {};
+    let match = {};
+    for (const [key, value] of Object.entries(filters)) {
+        if (value) {
+            if (value.eq !== undefined) {
+                if (typeof value.eq === 'string' && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)
+                    && key.endsWith('Id') && entityUtils.isValidObjectId(value.eq)) {
+                    match[key] = new ObjectId(value.eq);
+                }
+                else {
+                    match[key] = value.eq;
+                }
+            }
+            else if (value.gte !== undefined) {
+                match[key] = { $gte: value.gte };
+            }
+            else if (value.lte !== undefined) {
+                match[key] = { $lte: value.lte };
+            }
+            else if (value.gt !== undefined) {
+                match[key] = { $gt: value.gt };
+            }
+            else if (value.lt !== undefined) {
+                match[key] = { $lt: value.lt };
+            }
+            else if (value.contains !== undefined) {
+                match[key] = { $regex: value.contains, $options: 'i' };
+            }
+        }
+    }
+    return { $match: match };
+}
+function buildSQLWhereClauseFromQueryOptions(queryOptions, columnAliasMap) {
+    const filters = queryOptions.filters || {};
+    let whereClause = '';
+    for (const [key, value] of Object.entries(filters)) {
+        if (value) {
+            const tableAlias = (columnAliasMap && columnAliasMap[key]) || '';
+            whereClause = addKeyValueToWhereClause(whereClause, key, value, tableAlias);
+        }
+    }
+    return whereClause;
+}
+function addKeyValueToWhereClause(whereClause, key, value, tableAlias = '') {
+    let column = tableAlias ? `${tableAlias}.${stringUtils.pascalCase(key)}` : stringUtils.pascalCase(key);
+    let formattedValue = '';
+    let operator = '=';
+    if (value) {
+        if (value.eq !== undefined) {
+            formattedValue = formatValue(value.eq);
+            operator = '=';
+        }
+        else if (value.gte !== undefined) {
+            formattedValue = formatValue(value.gte);
+            operator = '>=';
+        }
+        else if (value.lte !== undefined) {
+            formattedValue = formatValue(value.lte);
+            operator = '<=';
+        }
+        else if (value.gt !== undefined) {
+            formattedValue = formatValue(value.gt);
+            operator = '>';
+        }
+        else if (value.lt !== undefined) {
+            formattedValue = formatValue(value.lt);
+            operator = '<';
+        }
+        else if (value.contains !== undefined) {
+            column = `LOWER(${column})`;
+            formattedValue = formatValue(value.contains, true).toLowerCase();
+            operator = 'LIKE';
+        }
+    }
+    const condition = `${column} ${operator} ${formattedValue}`;
+    return appendToWhereClause(whereClause, condition);
+}
+function appendToWhereClause(whereClause, condition) {
+    let newWhereClause = whereClause.trim();
+    if (newWhereClause.toUpperCase() === 'WHERE' || newWhereClause === '') {
+        newWhereClause = `WHERE ${condition}`;
+    }
+    else {
+        newWhereClause = `${newWhereClause} AND ${condition}`;
+    }
+    return newWhereClause;
+}
+function formatValue(value, isLikeOperator = false) {
+    if (typeof value === 'string') {
+        if (!isNaN(Number(value))) {
+            return value;
+        }
+        if (value.toLowerCase() === 'true') {
+            return 'TRUE';
+        }
+        if (value.toLowerCase() === 'false') {
+            return 'FALSE';
+        }
+        return isLikeOperator ? `'%${value}%'` : `'${value}'`;
+    }
+    else if (typeof value === 'number') {
+        return value.toString();
+    }
+    else if (typeof value === 'boolean') {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    else if (value instanceof Date) {
+        const dateString = value.toISOString().split('T')[0];
+        return `DATETIME('${dateString}')`;
+    }
+    else {
+        throw new Error('Unsupported value type');
+    }
+}
+export const dbUtils = {
+    buildMongoMatchFromQueryOptions,
+    buildSQLWhereClauseFromQueryOptions,
+    addKeyValueToWhereClause,
+    appendToWhereClause,
+    formatValue,
+    convertStringToObjectId,
+    convertStringsToObjectIds,
+    convertObjectIdsToStrings,
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './address.utils.js';
+export * from './api.utils.js';
+export * from './conversion.utils.js';
+export * from './db.utils.js';
+export * from './password.utils.js';
+export * from './string.utils.js';

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+export * from './address.utils.js';
+export * from './api.utils.js';
+export * from './conversion.utils.js';
+export * from './db.utils.js';
+export * from './password.utils.js';
+export * from './string.utils.js';

package/dist/utils/password.utils.d.ts

@@ -0,0 +1,7 @@
+declare function hashPassword(password: string): Promise<string>;
+declare function comparePasswords(storedPassword: string, suppliedPassword: string): Promise<boolean>;
+export declare const passwordUtils: {
+    hashPassword: typeof hashPassword;
+    comparePasswords: typeof comparePasswords;
+};
+export {};

package/dist/utils/password.utils.js

@@ -0,0 +1,23 @@
+import { scrypt, randomBytes } from 'node:crypto';
+import { promisify } from 'util';
+const scryptAsync = promisify(scrypt);
+async function hashPassword(password) {
+    const salt = randomBytes(8).toString('hex');
+    const buf = (await scryptAsync(password, salt, 64));
+    return `${buf.toString('hex')}.${salt}`;
+}
+async function comparePasswords(storedPassword, suppliedPassword) {
+    if (!storedPassword || !storedPassword.includes('.')) {
+        return false;
+    }
+    const [hashedPassword, salt] = storedPassword.split('.');
+    if (!salt) {
+        return false;
+    }
+    const buf = (await scryptAsync(suppliedPassword, salt, 64));
+    return buf.toString('hex') === hashedPassword;
+}
+export const passwordUtils = {
+    hashPassword,
+    comparePasswords
+};

package/dist/utils/string.utils.d.ts

@@ -0,0 +1,9 @@
+declare function camelCase(str: string): string;
+declare function pascalCase(str: string): string;
+declare function kebabCase(str: string): string;
+export declare const stringUtils: {
+    camelCase: typeof camelCase;
+    pascalCase: typeof pascalCase;
+    kebabCase: typeof kebabCase;
+};
+export {};

package/dist/utils/string.utils.js

@@ -0,0 +1,30 @@
+function camelCase(str) {
+    return str.split(/[\s-_]+|(?=[A-Z])/)
+        .map((word, index) => {
+        if (index === 0) {
+            return word.charAt(0).toLowerCase() + word.slice(1);
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+}
+function pascalCase(str) {
+    return str.split(/[-_]/)
+        .map(word => {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    })
+        .join('');
+}
+function kebabCase(str) {
+    let result = str.replace(/([a-z])([A-Z])/g, '$1-$2');
+    result = result.toLowerCase()
+        .replace(/[ _]/g, '-');
+    result = result.replace(/-{2,}/g, '-')
+        .replace(/^-|-$/g, '');
+    return result;
+}
+export const stringUtils = {
+    camelCase,
+    pascalCase,
+    kebabCase
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@loomcore/api",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "tsc": "tsc --project tsconfig.prod.json",
+    "build": "npm-run-all -s clean tsc",
+    "add": "git add .",
+    "commit": "git commit -m \"Updates\"",
+    "patch": "npm version patch",
+    "push": "git push",
+    "publishMe": "npm publish --access public",
+    "pub": "npm-run-all -s add commit patch build push publishMe",
+    "update-lib-versions": "npx --yes npm-check-updates -u -f @loomcore/models",
+    "install-updated-libs": "npm i @loomcore/models",
+    "update-libs": "npm-run-all -s update-lib-versions install-updated-libs",
+    
+    "typecheck": "tsc",
+    "test": "cross-env NODE_ENV=test vitest run",
+    "test:ci": "cross-env NODE_ENV=test vitest run --reporter=json --outputFile=test-results.json",
+    "test:watch": "cross-env NODE_ENV=test vitest",
+    "coverage": "cross-env NODE_ENV=test vitest run --coverage"
+  },
+  "author": "Tim Hardy",
+  "license": "Apache 2.0",
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "exports": {
+    "./config": "./dist/config/index.js",
+    "./controllers": "./dist/controllers/index.js",
+    "./errors": "./dist/errors/index.js",
+    "./middleware": "./dist/middleware/index.js",
+    "./models": "./dist/models/index.js",
+    "./services": "./dist/services/index.js",
+    "./utils": "./dist/utils/index.js"
+  },
+  "dependencies": {
+    "@sendgrid/mail": "^8.1.4",
+    "jsonwebtoken": "^9.0.2"
+  },
+  "peerDependencies": {
+    "@loomcore/common": "^0.0.6",
+    "@sinclair/typebox": "^0.34.31",
+    "cookie-parser": "^1.4.6",
+    "express": "^5.1.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "mongodb": "^6.16.0"
+  },
+  "devDependencies": {
+    "@types/cookie-parser": "^1.4.7",
+    "@types/express": "^5.0.1",
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/lodash": "^4.17.13",
+    "@types/supertest": "^6.0.3",
+    "@vitest/coverage-v8": "^3.0.9",
+    "cross-env": "^7.0.3",
+    "mongodb-memory-server": "^9.3.0",
+    "npm-run-all": "^4.1.5",
+    "supertest": "^7.1.0",
+    "typescript": "^5.8.3",
+    "vite": "^6.2.5",
+    "vitest": "^3.0.9"
+  }
+}