@loomcore/api 0.2.35 → 0.2.37

package/dist/databases/migrations/migration-runner.js

@@ -3,6 +3,7 @@ import { Pool } from 'pg';
 import { MongoClient } from 'mongodb';
 import fs from 'fs';
 import path from 'path';
+import { pathToFileURL } from 'node:url';
 import { buildMongoUrl } from '../mongo-db/utils/build-mongo-url.util.js';
 import { buildPostgresUrl } from '../postgres/utils/build-postgres-url.util.js';
 import { getPostgresInitialSchema } from '../postgres/migrations/postgres-initial-schema.js';
@@ -144,14 +145,15 @@ export class MigrationRunner {
                 };
             }
             else {
+                const importUrl = pathToFileURL(fullPath).href;
                 return {
                     name: f,
                     up: async () => {
-                        const mod = await import(fullPath);
+                        const mod = await import(importUrl);
                         await mod.up({ context });
                     },
                     down: async () => {
-                        const mod = await import(fullPath);
+                        const mod = await import(importUrl);
                         await mod.down({ context });
                     }
                 };

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -29,16 +29,16 @@ export const getMongoInitialSchema = (dbConfig) => {
         migrations.push({
             name: "00000000000001_schema-organizations-domains",
             up: async ({ context: db }) => {
-                await db.createCollection("organization_domains");
+                await db.createCollection("organizationDomains");
                 await db
-                    .collection("organization_domains")
+                    .collection("organizationDomains")
                     .createIndex({ domain: 1 }, { unique: true });
                 await db
-                    .collection("organization_domains")
+                    .collection("organizationDomains")
                     .createIndex({ organizationId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection("organization_domains").drop();
+                await db.collection("organizationDomains").drop();
             },
         });
     }
@@ -70,41 +70,41 @@ export const getMongoInitialSchema = (dbConfig) => {
         migrations.push({
             name: "00000000000003_schema-refresh-tokens",
             up: async ({ context: db }) => {
-                await db.createCollection("refresh_tokens");
+                await db.createCollection("refreshTokens");
                 await db
-                    .collection("refresh_tokens")
+                    .collection("refreshTokens")
                     .createIndex({ token: 1 }, { unique: true });
-                await db.collection("refresh_tokens").createIndex({ userId: 1 });
-                await db.collection("refresh_tokens").createIndex({ deviceId: 1 });
+                await db.collection("refreshTokens").createIndex({ userId: 1 });
+                await db.collection("refreshTokens").createIndex({ deviceId: 1 });
                 if (isMultiTenant) {
-                    await db.collection("refresh_tokens").createIndex({ _orgId: 1 });
+                    await db.collection("refreshTokens").createIndex({ _orgId: 1 });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection("refresh_tokens").drop();
+                await db.collection("refreshTokens").drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
             name: "00000000000004_schema-password-reset-tokens",
             up: async ({ context: db }) => {
-                await db.createCollection("password_reset_tokens");
+                await db.createCollection("passwordResetTokens");
                 if (isMultiTenant) {
                     await db
-                        .collection("password_reset_tokens")
+                        .collection("passwordResetTokens")
                         .createIndex({ _orgId: 1, email: 1 }, { unique: true });
                     await db
-                        .collection("password_reset_tokens")
+                        .collection("passwordResetTokens")
                         .createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("password_reset_tokens")
+                        .collection("passwordResetTokens")
                         .createIndex({ email: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection("password_reset_tokens").drop();
+                await db.collection("passwordResetTokens").drop();
             },
         });
     if (isAuthEnabled)
@@ -132,23 +132,23 @@ export const getMongoInitialSchema = (dbConfig) => {
         migrations.push({
             name: "00000000000006_schema-user-roles",
             up: async ({ context: db }) => {
-                await db.createCollection("user_roles");
+                await db.createCollection("userRoles");
                 if (isMultiTenant) {
                     await db
-                        .collection("user_roles")
+                        .collection("userRoles")
                         .createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
-                    await db.collection("user_roles").createIndex({ _orgId: 1 });
+                    await db.collection("userRoles").createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("user_roles")
+                        .collection("userRoles")
                         .createIndex({ userId: 1, roleId: 1 }, { unique: true });
                 }
-                await db.collection("user_roles").createIndex({ userId: 1 });
-                await db.collection("user_roles").createIndex({ roleId: 1 });
+                await db.collection("userRoles").createIndex({ userId: 1 });
+                await db.collection("userRoles").createIndex({ roleId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection("user_roles").drop();
+                await db.collection("userRoles").drop();
             },
         });
     if (isAuthEnabled)
@@ -222,7 +222,7 @@ export const getMongoInitialSchema = (dbConfig) => {
                 };
                 const metaOrgDomains = dbConfig.multiTenant.metaOrgDomains ?? [];
                 if (metaOrgDomains.length > 0) {
-                    await db.collection("organization_domains").insertMany(metaOrgDomains.map((domain) => ({
+                    await db.collection("organizationDomains").insertMany(metaOrgDomains.map((domain) => ({
                         organizationId: metaOrg._id,
                         domain,
                         _created: new Date(),
@@ -234,7 +234,7 @@ export const getMongoInitialSchema = (dbConfig) => {
                 initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", metaOrg);
             },
             down: async ({ context: db }) => {
-                await db.collection("organization_domains").deleteMany({});
+                await db.collection("organizationDomains").deleteMany({});
                 await db.collection("organizations").deleteMany({ isMetaOrg: true });
             },
         });
@@ -299,7 +299,7 @@ export const getMongoInitialSchema = (dbConfig) => {
                     ...orgDoc,
                     name: "admin",
                 });
-                await db.collection("user_roles").insertOne({
+                await db.collection("userRoles").insertOne({
                     ...orgDoc,
                     userId: adminUser._id,
                     roleId: roleResult.insertedId,
@@ -355,7 +355,7 @@ export const getMongoInitialSchema = (dbConfig) => {
                     .collection("features")
                     .deleteMany({ ...orgFilter, name: "admin" });
                 if (adminRole) {
-                    await db.collection("user_roles").deleteMany({
+                    await db.collection("userRoles").deleteMany({
                         ...orgFilter,
                         roleId: adminRole._id,
                     });

package/dist/databases/postgres/postgres.database.js

@@ -12,7 +12,7 @@ import { get as getQuery } from "./queries/postgres-get.query.js";
 import { getAll as getAllQuery } from "./queries/postgres-get-all.query.js";
 import { getById as getByIdQuery } from "./queries/postgres-get-by-id.query.js";
 import { getCount as getCountQuery } from "./queries/postgres-get-count.query.js";
-import { convertKeysToCamelCase, convertKeysToSnakeCase, } from "./utils/convert-keys.util.js";
+import { convertKeysToCamelCase, convertKeysToSnakeCase, toPostgresStoreName, } from "./utils/convert-keys.util.js";
 import { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
 export class PostgresDatabase {
     connection;
@@ -36,45 +36,45 @@ export class PostgresDatabase {
         return convertKeysToCamelCase(withNullsConverted);
     }
     async getAll(operations, pluralResourceName) {
-        return getAllQuery(this.connection, operations, pluralResourceName);
+        return getAllQuery(this.connection, operations, toPostgresStoreName(pluralResourceName));
     }
     async get(operations, queryOptions, modelSpec, pluralResourceName) {
-        return getQuery(this.connection, operations, queryOptions, pluralResourceName);
+        return getQuery(this.connection, operations, queryOptions, toPostgresStoreName(pluralResourceName));
     }
     async getById(operations, queryObject, id, pluralResourceName) {
-        return getByIdQuery(this.connection, operations, queryObject, id, pluralResourceName);
+        return getByIdQuery(this.connection, operations, queryObject, id, toPostgresStoreName(pluralResourceName));
     }
     async getCount(pluralResourceName) {
-        return getCountQuery(this.connection, pluralResourceName);
+        return getCountQuery(this.connection, toPostgresStoreName(pluralResourceName));
     }
     async create(entity, pluralResourceName) {
-        return createCommand(this.connection, pluralResourceName, entity);
+        return createCommand(this.connection, toPostgresStoreName(pluralResourceName), entity);
     }
     async createMany(entities, pluralResourceName) {
-        return createManyCommand(this.connection, pluralResourceName, entities);
+        return createManyCommand(this.connection, toPostgresStoreName(pluralResourceName), entities);
     }
     async batchUpdate(entities, operations, queryObject, pluralResourceName) {
-        return batchUpdateCommand(this.connection, entities, operations, queryObject, pluralResourceName);
+        return batchUpdateCommand(this.connection, entities, operations, queryObject, toPostgresStoreName(pluralResourceName));
     }
     async fullUpdateById(operations, id, entity, pluralResourceName) {
-        return fullUpdateByIdCommand(this.connection, operations, id, entity, pluralResourceName);
+        return fullUpdateByIdCommand(this.connection, operations, id, entity, toPostgresStoreName(pluralResourceName));
     }
     async partialUpdateById(operations, id, entity, pluralResourceName) {
-        return partialUpdateByIdCommand(this.connection, operations, id, entity, pluralResourceName);
+        return partialUpdateByIdCommand(this.connection, operations, id, entity, toPostgresStoreName(pluralResourceName));
     }
     async update(queryObject, entity, operations, pluralResourceName) {
-        return updateCommand(this.connection, queryObject, entity, operations, pluralResourceName);
+        return updateCommand(this.connection, queryObject, entity, operations, toPostgresStoreName(pluralResourceName));
     }
     async deleteById(id, pluralResourceName) {
-        return deleteByIdCommand(this.connection, id, pluralResourceName);
+        return deleteByIdCommand(this.connection, id, toPostgresStoreName(pluralResourceName));
     }
     async deleteMany(queryObject, pluralResourceName) {
-        return deleteManyCommand(this.connection, queryObject, pluralResourceName);
+        return deleteManyCommand(this.connection, queryObject, toPostgresStoreName(pluralResourceName));
     }
     async find(queryObject, pluralResourceName) {
-        return findQuery(this.connection, queryObject, pluralResourceName);
+        return findQuery(this.connection, queryObject, toPostgresStoreName(pluralResourceName));
     }
     async findOne(queryObject, pluralResourceName) {
-        return findOneQuery(this.connection, queryObject, pluralResourceName);
+        return findOneQuery(this.connection, queryObject, toPostgresStoreName(pluralResourceName));
     }
 }

package/dist/databases/postgres/utils/build-join-clauses.js

@@ -1,6 +1,7 @@
 import { LeftJoin } from "../../operations/left-join.operation.js";
 import { InnerJoin } from "../../operations/inner-join.operation.js";
 import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
+import { toPostgresStoreName } from "./convert-keys.util.js";
 function getParentAlias(localField) {
     if (!localField.includes('.'))
         return null;
@@ -45,7 +46,8 @@ export function buildJoinClauses(operations, mainTableName, options) {
             else {
                 leftSide = mainTableName ? `"${mainTableName}"."${operation.localField}"` : `"${operation.localField}"`;
             }
-            joinClauses.push(`${joinType} "${operation.from}" AS "${operation.as}" ON ${leftSide} = "${operation.as}"."${operation.foreignField}"`);
+            const fromTable = toPostgresStoreName(operation.from);
+            joinClauses.push(`${joinType} "${fromTable}" AS "${operation.as}" ON ${leftSide} = "${operation.as}"."${operation.foreignField}"`);
         }
     }
     return joinClauses.join(' ');

package/dist/databases/postgres/utils/build-select-clause.js

@@ -1,15 +1,17 @@
 import { LeftJoin } from '../../operations/left-join.operation.js';
 import { InnerJoin } from '../../operations/inner-join.operation.js';
 import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
+import { toPostgresStoreName } from './convert-keys.util.js';
 const PK = '_id';
 export async function getTableColumns(client, tableName) {
+    const storeName = toPostgresStoreName(tableName);
     const result = await client.query(`
             SELECT column_name
             FROM information_schema.columns
             WHERE table_schema = current_schema()
               AND table_name = $1
             ORDER BY ordinal_position
-        `, [tableName]);
+        `, [storeName]);
     return result.rows.map(row => row.column_name);
 }
 function getParentAlias(localField) {
@@ -93,19 +95,21 @@ async function buildManyValue(client, op, operations, mainTableName, parentAlias
     if (throughJoin) {
         const throughAlias = throughJoin.as;
         const linkColumn = op.localField.split('.')[1];
-        fromClause = `"${throughJoin.from}" AS "${throughAlias}" INNER JOIN "${op.from}" AS "${alias}" ON "${throughAlias}"."${linkColumn}" = "${alias}"."${op.foreignField}"`;
+        const throughFrom = toPostgresStoreName(throughJoin.from);
+        const opFrom = toPostgresStoreName(op.from);
+        fromClause = `"${throughFrom}" AS "${throughAlias}" INNER JOIN "${opFrom}" AS "${alias}" ON "${throughAlias}"."${linkColumn}" = "${alias}"."${op.foreignField}"`;
         const throughParentRef = buildParentRef(throughJoin.localField, mainTableName);
         whereClause = `"${throughAlias}"."${throughJoin.foreignField}" = ${throughParentRef}`;
     }
     else {
-        fromClause = `"${op.from}" AS "${alias}"`;
+        fromClause = `"${toPostgresStoreName(op.from)}" AS "${alias}"`;
         whereClause = `"${alias}"."${op.foreignField}" = ${parentRef}`;
     }
     const throughAliasesUsedBySiblings = getThroughAliasesUsedBySiblings(childOps);
     const oneToOneChildren = childOps.filter(c => c instanceof LeftJoin || c instanceof InnerJoin);
     for (const child of oneToOneChildren) {
         const leftCol = child.localField.includes('.') ? child.localField.split('.')[1] : child.localField;
-        fromClause += ` LEFT JOIN "${child.from}" AS "${child.as}" ON "${alias}"."${leftCol}" = "${child.as}"."${child.foreignField}"`;
+        fromClause += ` LEFT JOIN "${toPostgresStoreName(child.from)}" AS "${child.as}" ON "${alias}"."${leftCol}" = "${child.as}"."${child.foreignField}"`;
     }
     const itemEntries = columns.map(col => ({
         key: col,

package/dist/databases/postgres/utils/convert-keys.util.d.ts

@@ -1,4 +1,5 @@
 export declare function toSnakeCase(str: string): string;
+export declare function toPostgresStoreName(logicalResourceName: string): string;
 export declare function toCamelCase(str: string): string;
 export declare function convertKeysToSnakeCase<T>(obj: T): T;
 export declare function convertKeysToCamelCase<T>(obj: T): T;

package/dist/databases/postgres/utils/convert-keys.util.js

@@ -7,6 +7,9 @@ export function toSnakeCase(str) {
         .replace(/^_|_$/g, '');
     return result;
 }
+export function toPostgresStoreName(logicalResourceName) {
+    return toSnakeCase(logicalResourceName);
+}
 export function toCamelCase(str) {
     return str.split(/[-_]+/)
         .map((word, index) => {

package/dist/databases/postgres/utils/does-table-exist.util.js

@@ -1,8 +1,10 @@
+import { toPostgresStoreName } from "./convert-keys.util.js";
 export async function doesTableExist(client, tableName) {
+    const storeName = toPostgresStoreName(tableName);
     const result = await client.query(`
         SELECT EXISTS (
             SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1
         )
-    `, [tableName]);
+    `, [storeName]);
     return result.rows[0].exists;
 }

package/dist/databases/postgres/utils/index.d.ts

@@ -3,4 +3,5 @@ export * from './does-table-exist.util.js';
 export * from './build-where-clause.js';
 export * from './build-pagination-clause.js';
 export * from './build-order-by-clause.js';
+export * from './convert-keys.util.js';
 export * from './convert-null-to-undefined.util.js';

package/dist/databases/postgres/utils/index.js

@@ -3,4 +3,5 @@ export * from './does-table-exist.util.js';
 export * from './build-where-clause.js';
 export * from './build-pagination-clause.js';
 export * from './build-order-by-clause.js';
+export * from './convert-keys.util.js';
 export * from './convert-null-to-undefined.util.js';

package/dist/services/organization-domain.service.js

@@ -2,6 +2,6 @@ import { OrganizationDomainSpec, } from "@loomcore/common/models";
 import { GenericApiService } from "./generic-api-service/generic-api.service.js";
 export class OrganizationDomainService extends GenericApiService {
     constructor(database) {
-        super(database, "organization_domains", "organization_domain", OrganizationDomainSpec);
+        super(database, "organizationDomains", "organizationDomain", OrganizationDomainSpec);
     }
 }

package/dist/services/password-reset-token.service.js

@@ -3,7 +3,7 @@ import { PasswordResetTokenSpec, } from "@loomcore/common/models";
 import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export class PasswordResetTokenService extends MultiTenantApiService {
     constructor(database) {
-        super(database, "password_reset_tokens", "password_reset_token", PasswordResetTokenSpec);
+        super(database, "passwordResetTokens", "passwordResetToken", PasswordResetTokenSpec);
     }
     async createPasswordResetToken(userContext, email, expiresOn) {
         const lowerCaseEmail = email.toLowerCase();

package/dist/services/refresh-token.service.js

@@ -2,6 +2,6 @@ import { refreshTokenModelSpec } from "@loomcore/common/models";
 import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export class RefreshTokenService extends MultiTenantApiService {
     constructor(database) {
-        super(database, "refresh_tokens", "refresh_token", refreshTokenModelSpec);
+        super(database, "refreshTokens", "refreshToken", refreshTokenModelSpec);
     }
 }

package/dist/services/user-roles.service.js

@@ -3,7 +3,7 @@ import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 import { assertUserHasFeature } from "../utils/index.js";
 export class UserRolesService extends MultiTenantApiService {
     constructor(database) {
-        super(database, "user_roles", "user_role", UserRoleModelSpec);
+        super(database, "userRoles", "userRole", UserRoleModelSpec);
     }
     async preProcessEntity(userContext, entity, isCreate, allowId = true) {
         assertUserHasFeature(userContext, ['admin', 'system', 'user-roles']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {