@loomcore/api 0.2.42 → 0.2.45

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

@@ -1,203 +1,203 @@
-import { EmptyUserContext, getSystemUserContext, initializeSystemUserContext, isSystemUserContextInitialized, } from "@loomcore/common/models";
-import { OrganizationService } from "../../../services/index.js";
-import { passwordUtils } from "../../../utils/index.js";
-import { MongoDBDatabase } from "../mongo-db.database.js";
+import { EmptyUserContext, getSystemUserContext, initializeSystemUserContext, isSystemUserContextInitialized, } from '@loomcore/common/models';
+import { OrganizationService } from '../../../services/index.js';
+import { passwordUtils } from '../../../utils/index.js';
+import { MongoDBDatabase } from '../mongo-db.database.js';
 export const getMongoInitialSchema = (dbConfig) => {
     const migrations = [];
     const isMultiTenant = dbConfig.app.isMultiTenant;
     if (isMultiTenant && !dbConfig.multiTenant) {
-        throw new Error("Multi-tenant configuration is enabled but multi-tenant configuration is not provided");
+        throw new Error('Multi-tenant configuration is enabled but multi-tenant configuration is not provided');
     }
     const isAuthEnabled = dbConfig.app.isAuthEnabled;
     if (isMultiTenant) {
         migrations.push({
-            name: "00000000000001_schema-organizations",
+            name: '00000000000001_schema-organizations',
             up: async ({ context: db }) => {
-                await db.createCollection("organizations");
+                await db.createCollection('organizations');
                 await db
-                    .collection("organizations")
+                    .collection('organizations')
                     .createIndex({ name: 1 }, { unique: true });
                 await db
-                    .collection("organizations")
+                    .collection('organizations')
                     .createIndex({ code: 1 }, { unique: true });
-                await db.collection("organizations").createIndex({ isMetaOrg: 1 });
+                await db.collection('organizations').createIndex({ isMetaOrg: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection("organizations").drop();
+                await db.collection('organizations').drop();
             },
         });
         migrations.push({
-            name: "00000000000001_schema-organizations-domains",
+            name: '00000000000001_schema-organizations-domains',
             up: async ({ context: db }) => {
-                await db.createCollection("organizationDomains");
+                await db.createCollection('organizationDomains');
                 await db
-                    .collection("organizationDomains")
+                    .collection('organizationDomains')
                     .createIndex({ domain: 1 }, { unique: true });
                 await db
-                    .collection("organizationDomains")
+                    .collection('organizationDomains')
                     .createIndex({ organizationId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection("organizationDomains").drop();
+                await db.collection('organizationDomains').drop();
             },
         });
     }
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000002_schema-users",
+            name: '00000000000002_schema-users',
             up: async ({ context: db }) => {
-                await db.createCollection("users");
+                await db.createCollection('users');
                 if (dbConfig.app.isMultiTenant) {
                     await db
-                        .collection("users")
+                        .collection('users')
                         .createIndex({ _orgId: 1, email: 1 }, { unique: true });
-                    await db.collection("users").createIndex({ _orgId: 1 });
+                    await db.collection('users').createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("users")
+                        .collection('users')
                         .createIndex({ email: 1 }, { unique: true });
                 }
                 await db
-                    .collection("users")
+                    .collection('users')
                     .createIndex({ externalId: 1 }, { unique: true, sparse: true });
             },
             down: async ({ context: db }) => {
-                await db.collection("users").drop();
+                await db.collection('users').drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000003_schema-refresh-tokens",
+            name: '00000000000003_schema-refresh-tokens',
             up: async ({ context: db }) => {
-                await db.createCollection("refreshTokens");
+                await db.createCollection('refreshTokens');
                 await db
-                    .collection("refreshTokens")
+                    .collection('refreshTokens')
                     .createIndex({ token: 1 }, { unique: true });
-                await db.collection("refreshTokens").createIndex({ userId: 1 });
-                await db.collection("refreshTokens").createIndex({ deviceId: 1 });
+                await db.collection('refreshTokens').createIndex({ userId: 1 });
+                await db.collection('refreshTokens').createIndex({ deviceId: 1 });
                 if (isMultiTenant) {
-                    await db.collection("refreshTokens").createIndex({ _orgId: 1 });
+                    await db.collection('refreshTokens').createIndex({ _orgId: 1 });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection("refreshTokens").drop();
+                await db.collection('refreshTokens').drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000004_schema-password-reset-tokens",
+            name: '00000000000004_schema-password-reset-tokens',
             up: async ({ context: db }) => {
-                await db.createCollection("passwordResetTokens");
+                await db.createCollection('passwordResetTokens');
                 if (isMultiTenant) {
                     await db
-                        .collection("passwordResetTokens")
+                        .collection('passwordResetTokens')
                         .createIndex({ _orgId: 1, email: 1 }, { unique: true });
                     await db
-                        .collection("passwordResetTokens")
+                        .collection('passwordResetTokens')
                         .createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("passwordResetTokens")
+                        .collection('passwordResetTokens')
                         .createIndex({ email: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection("passwordResetTokens").drop();
+                await db.collection('passwordResetTokens').drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000005_schema-roles",
+            name: '00000000000005_schema-roles',
             up: async ({ context: db }) => {
-                await db.createCollection("roles");
+                await db.createCollection('roles');
                 if (isMultiTenant) {
                     await db
-                        .collection("roles")
+                        .collection('roles')
                         .createIndex({ _orgId: 1, name: 1 }, { unique: true });
-                    await db.collection("roles").createIndex({ _orgId: 1 });
+                    await db.collection('roles').createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("roles")
+                        .collection('roles')
                         .createIndex({ name: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection("roles").drop();
+                await db.collection('roles').drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000006_schema-user-roles",
+            name: '00000000000006_schema-user-roles',
             up: async ({ context: db }) => {
-                await db.createCollection("userRoles");
+                await db.createCollection('userRoles');
                 if (isMultiTenant) {
                     await db
-                        .collection("userRoles")
+                        .collection('userRoles')
                         .createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
-                    await db.collection("userRoles").createIndex({ _orgId: 1 });
+                    await db.collection('userRoles').createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("userRoles")
+                        .collection('userRoles')
                         .createIndex({ userId: 1, roleId: 1 }, { unique: true });
                 }
-                await db.collection("userRoles").createIndex({ userId: 1 });
-                await db.collection("userRoles").createIndex({ roleId: 1 });
+                await db.collection('userRoles').createIndex({ userId: 1 });
+                await db.collection('userRoles').createIndex({ roleId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection("userRoles").drop();
+                await db.collection('userRoles').drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000007_schema-features",
+            name: '00000000000007_schema-features',
             up: async ({ context: db }) => {
-                await db.createCollection("features");
+                await db.createCollection('features');
                 if (isMultiTenant) {
                     await db
-                        .collection("features")
+                        .collection('features')
                         .createIndex({ _orgId: 1, name: 1 }, { unique: true });
-                    await db.collection("features").createIndex({ _orgId: 1 });
+                    await db.collection('features').createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("features")
+                        .collection('features')
                         .createIndex({ name: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection("features").drop();
+                await db.collection('features').drop();
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000008_schema-authorizations",
+            name: '00000000000008_schema-authorizations',
             up: async ({ context: db }) => {
-                await db.createCollection("authorizations");
+                await db.createCollection('authorizations');
                 if (isMultiTenant) {
                     await db
-                        .collection("authorizations")
+                        .collection('authorizations')
                         .createIndex({ _orgId: 1, roleId: 1, featureId: 1 }, { unique: true });
-                    await db.collection("authorizations").createIndex({ _orgId: 1 });
+                    await db.collection('authorizations').createIndex({ _orgId: 1 });
                 }
                 else {
                     await db
-                        .collection("authorizations")
+                        .collection('authorizations')
                         .createIndex({ roleId: 1, featureId: 1 }, { unique: true });
                 }
-                await db.collection("authorizations").createIndex({ roleId: 1 });
-                await db.collection("authorizations").createIndex({ featureId: 1 });
+                await db.collection('authorizations').createIndex({ roleId: 1 });
+                await db.collection('authorizations').createIndex({ featureId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection("authorizations").drop();
+                await db.collection('authorizations').drop();
             },
         });
     if (isMultiTenant) {
         migrations.push({
-            name: "00000000000009_data-meta-org",
+            name: '00000000000009_data-meta-org',
             up: async ({ context: db }) => {
                 const metaOrgDoc = {
                     name: dbConfig.multiTenant.metaOrgName,
@@ -207,14 +207,14 @@ export const getMongoInitialSchema = (dbConfig) => {
                     isMetaOrg: true,
                     authToken: undefined,
                     _created: new Date(),
-                    _createdBy: "system",
+                    _createdBy: 'system',
                     _updated: new Date(),
-                    _updatedBy: "system",
+                    _updatedBy: 'system',
                     _deleted: undefined,
                     _deletedBy: undefined,
                 };
                 const result = await db
-                    .collection("organizations")
+                    .collection('organizations')
                     .insertOne(metaOrgDoc);
                 const metaOrgObjectId = result.insertedId;
                 const metaOrg = {
@@ -223,33 +223,33 @@ export const getMongoInitialSchema = (dbConfig) => {
                 };
                 const metaOrgDomains = dbConfig.multiTenant.metaOrgDomains ?? [];
                 if (metaOrgDomains.length > 0) {
-                    await db.collection("organizationDomains").insertMany(metaOrgDomains.map((domain) => ({
+                    await db.collection('organizationDomains').insertMany(metaOrgDomains.map((domain) => ({
                         organizationId: metaOrgObjectId,
                         domain,
                         _created: new Date(),
-                        _createdBy: "system",
+                        _createdBy: 'system',
                         _updated: new Date(),
-                        _updatedBy: "system",
+                        _updatedBy: 'system',
                     })));
                 }
-                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", metaOrg);
+                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || 'system@example.com', metaOrg);
             },
             down: async ({ context: db }) => {
-                await db.collection("organizationDomains").deleteMany({});
-                await db.collection("organizations").deleteMany({ isMetaOrg: true });
+                await db.collection('organizationDomains').deleteMany({});
+                await db.collection('organizations').deleteMany({ isMetaOrg: true });
             },
         });
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000010_data-admin-user",
+            name: '00000000000010_data-admin-user',
             up: async ({ context: db }) => {
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
-                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000009_data-meta-org) should have run before this migration. " +
-                            "Please ensure metaOrgName and metaOrgCode are provided in your dbConfig."
-                        : "BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.";
-                    console.error("❌ Migration Error:", errorMessage);
+                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000009_data-meta-org) should have run before this migration. ' +
+                            'Please ensure metaOrgName and metaOrgCode are provided in your dbConfig.'
+                        : 'BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.';
+                    console.error('❌ Migration Error:', errorMessage);
                     throw new Error(errorMessage);
                 }
                 const systemUserContext = getSystemUserContext();
@@ -258,29 +258,29 @@ export const getMongoInitialSchema = (dbConfig) => {
                     : {};
                 const hashedPassword = await passwordUtils.hashPassword(dbConfig.adminUser.password);
                 const email = dbConfig.adminUser.email.toLowerCase();
-                await db.collection("users").insertOne({
+                await db.collection('users').insertOne({
                     ...orgDoc,
                     email,
                     password: hashedPassword,
-                    displayName: "Admin User",
+                    displayName: 'Admin User',
                     _created: new Date(),
-                    _createdBy: "system",
+                    _createdBy: 'system',
                     _updated: new Date(),
-                    _updatedBy: "system",
+                    _updatedBy: 'system',
                 });
             },
             down: async ({ context: db }) => {
                 if (!dbConfig?.adminUser?.email)
                     return;
                 await db
-                    .collection("users")
+                    .collection('users')
                     .deleteOne({ email: dbConfig.adminUser.email.toLowerCase() });
             },
         });
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000011_data-admin-authorizations",
+            name: '00000000000011_data-admin-authorizations',
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
@@ -288,36 +288,36 @@ export const getMongoInitialSchema = (dbConfig) => {
                     ? await organizationService.getMetaOrg(EmptyUserContext)
                     : undefined;
                 if (isMultiTenant && !metaOrg) {
-                    throw new Error("Meta organization not found. Ensure meta-org migration ran successfully.");
+                    throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
                 }
                 const email = dbConfig.adminUser.email.toLowerCase();
-                const adminUser = await db.collection("users").findOne({ email });
+                const adminUser = await db.collection('users').findOne({ email });
                 if (!adminUser) {
-                    throw new Error("Admin user not found. Ensure admin-user migration ran successfully.");
+                    throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                 }
                 const orgDoc = isMultiTenant && metaOrg?._id
                     ? { _orgId: String(metaOrg._id) }
                     : {};
-                const roleResult = await db.collection("roles").insertOne({
+                const roleResult = await db.collection('roles').insertOne({
                     ...orgDoc,
-                    name: "admin",
+                    name: 'admin',
                 });
-                await db.collection("userRoles").insertOne({
+                await db.collection('userRoles').insertOne({
                     ...orgDoc,
                     userId: adminUser._id,
                     roleId: roleResult.insertedId,
                     _created: new Date(),
-                    _createdBy: "system",
+                    _createdBy: 'system',
                     _updated: new Date(),
-                    _updatedBy: "system",
+                    _updatedBy: 'system',
                     _deleted: undefined,
                     _deletedBy: undefined,
                 });
-                const featureResult = await db.collection("features").insertOne({
+                const featureResult = await db.collection('features').insertOne({
                     ...orgDoc,
-                    name: "admin",
+                    name: 'admin',
                 });
-                await db.collection("authorizations").insertOne({
+                await db.collection('authorizations').insertOne({
                     ...orgDoc,
                     roleId: roleResult.insertedId,
                     featureId: featureResult.insertedId,
@@ -325,9 +325,9 @@ export const getMongoInitialSchema = (dbConfig) => {
                     endDate: undefined,
                     config: undefined,
                     _created: new Date(),
-                    _createdBy: "system",
+                    _createdBy: 'system',
                     _updated: new Date(),
-                    _updatedBy: "system",
+                    _updatedBy: 'system',
                     _deleted: undefined,
                     _deletedBy: undefined,
                 });
@@ -344,30 +344,30 @@ export const getMongoInitialSchema = (dbConfig) => {
                     ? { _orgId: String(metaOrg._id) }
                     : {};
                 const adminRole = await db
-                    .collection("roles")
-                    .findOne({ ...orgFilter, name: "admin" });
+                    .collection('roles')
+                    .findOne({ ...orgFilter, name: 'admin' });
                 const adminFeature = await db
-                    .collection("features")
-                    .findOne({ ...orgFilter, name: "admin" });
+                    .collection('features')
+                    .findOne({ ...orgFilter, name: 'admin' });
                 if (adminRole && adminFeature) {
-                    await db.collection("authorizations").deleteMany({
+                    await db.collection('authorizations').deleteMany({
                         ...orgFilter,
                         roleId: adminRole._id,
                         featureId: adminFeature._id,
                     });
                 }
                 await db
-                    .collection("features")
-                    .deleteMany({ ...orgFilter, name: "admin" });
+                    .collection('features')
+                    .deleteMany({ ...orgFilter, name: 'admin' });
                 if (adminRole) {
-                    await db.collection("userRoles").deleteMany({
+                    await db.collection('userRoles').deleteMany({
                         ...orgFilter,
                         roleId: adminRole._id,
                     });
                 }
                 await db
-                    .collection("roles")
-                    .deleteMany({ ...orgFilter, name: "admin" });
+                    .collection('roles')
+                    .deleteMany({ ...orgFilter, name: 'admin' });
             },
         });
     }

package/dist/databases/mongo-db/models/no-sql-pipeline.d.ts

@@ -1,7 +1,7 @@
-import { Document } from "mongodb";
-import { IQueryOptions, IModelSpec } from "@loomcore/common/models";
-import { Operation } from "../../operations/operation.js";
-import { INoSqlPipeline } from "./no-sql-pipeline.interface.js";
+import { Document } from 'mongodb';
+import { IQueryOptions, IModelSpec } from '@loomcore/common/models';
+import { Operation } from '../../operations/operation.js';
+import { INoSqlPipeline } from './no-sql-pipeline.interface.js';
 declare class NoSqlPipeline implements INoSqlPipeline {
     private pipeline;
     constructor(pipeline?: Document[] | null);

package/dist/databases/mongo-db/models/no-sql-pipeline.interface.d.ts

@@ -1,6 +1,6 @@
-import { Document } from "mongodb";
-import { IQueryOptions, IModelSpec } from "@loomcore/common/models";
-import { Operation } from "../../operations/operation.js";
+import { Document } from 'mongodb';
+import { IQueryOptions, IModelSpec } from '@loomcore/common/models';
+import { Operation } from '../../operations/operation.js';
 export interface INoSqlPipeline {
     addStage(stage: Document): INoSqlPipeline;
     addStages(stages: Document[]): INoSqlPipeline;

package/dist/databases/mongo-db/models/no-sql-pipeline.js

@@ -1,4 +1,4 @@
-import { buildNoSqlMatch, convertOperationsToPipeline, convertQueryOptionsToPipeline } from "../utils/index.js";
+import { buildNoSqlMatch, convertOperationsToPipeline, convertQueryOptionsToPipeline } from '../utils/index.js';
 class NoSqlPipeline {
     pipeline;
     constructor(pipeline = null) {

package/dist/databases/mongo-db/mongo-db.database.d.ts

@@ -1,10 +1,10 @@
-import { Db, MongoClient } from "mongodb";
-import { IModelSpec, IQueryOptions, IPagedResult, IEntity } from "@loomcore/common/models";
-import type { AppIdType } from "@loomcore/common/types";
-import { Operation } from "../operations/operation.js";
-import { DeleteResult as GenericDeleteResult } from "../models/delete-result.js";
-import { TSchema } from "@sinclair/typebox";
-import { IDatabase } from "../models/database.interface.js";
+import { Db, MongoClient } from 'mongodb';
+import { IModelSpec, IQueryOptions, IPagedResult, IEntity } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
+import { Operation } from '../operations/operation.js';
+import { DeleteResult as GenericDeleteResult } from '../models/delete-result.js';
+import { TSchema } from '@sinclair/typebox';
+import { IDatabase } from '../models/database.interface.js';
 export declare class MongoDBDatabase implements IDatabase {
     private db;
     private mongoClient?;

package/dist/databases/mongo-db/mongo-db.database.js

@@ -1,8 +1,8 @@
-import { convertObjectIdsToStrings, convertStringsToObjectIds } from "./utils/index.js";
-import { create, createMany, batchUpdate, fullUpdateById, partialUpdateById, update, deleteById, deleteMany } from "./commands/index.js";
-import { getAll, get, getById, getCount, find, findOne } from "./queries/index.js";
-import { entityUtils } from "@loomcore/common/utils";
-import { BadRequestError } from "../../errors/bad-request.error.js";
+import { convertObjectIdsToStrings, convertStringsToObjectIds } from './utils/index.js';
+import { create, createMany, batchUpdate, fullUpdateById, partialUpdateById, update, deleteById, deleteMany } from './commands/index.js';
+import { getAll, get, getById, getCount, find, findOne } from './queries/index.js';
+import { entityUtils } from '@loomcore/common/utils';
+import { BadRequestError } from '../../errors/bad-request.error.js';
 export class MongoDBDatabase {
     db;
     mongoClient;

package/dist/databases/mongo-db/queries/mongo-find-one.query.d.ts

@@ -1,3 +1,3 @@
-import { Db } from "mongodb";
-import { IQueryOptions } from "@loomcore/common/models";
+import { Db } from 'mongodb';
+import { IQueryOptions } from '@loomcore/common/models';
 export declare function findOne<T>(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

package/dist/databases/mongo-db/queries/mongo-find-one.query.js

@@ -1,4 +1,4 @@
-import { buildNoSqlMatch, buildFindOptions } from "../utils/index.js";
+import { buildNoSqlMatch, buildFindOptions } from '../utils/index.js';
 export async function findOne(db, queryObject, pluralResourceName) {
     const collection = db.collection(pluralResourceName);
     const matchDocument = buildNoSqlMatch(queryObject);

package/dist/databases/mongo-db/queries/mongo-find.query.d.ts

@@ -1,3 +1,3 @@
-import { Db } from "mongodb";
-import { IQueryOptions } from "@loomcore/common/models";
+import { Db } from 'mongodb';
+import { IQueryOptions } from '@loomcore/common/models';
 export declare function find<T>(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/queries/mongo-find.query.js

@@ -1,4 +1,4 @@
-import { buildNoSqlMatch, buildFindOptions } from "../utils/index.js";
+import { buildNoSqlMatch, buildFindOptions } from '../utils/index.js';
 export async function find(db, queryObject, pluralResourceName) {
     const collection = db.collection(pluralResourceName);
     const matchDocument = buildNoSqlMatch(queryObject);

package/dist/databases/mongo-db/queries/mongo-get-all.query.d.ts

@@ -1,3 +1,3 @@
-import { Db } from "mongodb";
-import { Operation } from "../../operations/operation.js";
+import { Db } from 'mongodb';
+import { Operation } from '../../operations/operation.js';
 export declare function getAll<T>(db: Db, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/queries/mongo-get-all.query.js

@@ -1,4 +1,4 @@
-import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import NoSqlPipeline from '../models/no-sql-pipeline.js';
 export async function getAll(db, operations, pluralResourceName) {
     const collection = db.collection(pluralResourceName);
     const pipeline = new NoSqlPipeline()

package/dist/databases/mongo-db/queries/mongo-get-by-id.query.d.ts

@@ -1,5 +1,5 @@
-import { Db } from "mongodb";
-import { Operation } from "../../operations/operation.js";
-import { IQueryOptions } from "@loomcore/common/models";
-import type { AppIdType } from "@loomcore/common/types";
+import { Db } from 'mongodb';
+import { Operation } from '../../operations/operation.js';
+import { IQueryOptions } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
 export declare function getById<T>(db: Db, operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;

package/dist/databases/mongo-db/queries/mongo-get-by-id.query.js

@@ -1,6 +1,6 @@
-import { entityUtils } from "@loomcore/common/utils";
-import { BadRequestError } from "../../../errors/index.js";
-import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { entityUtils } from '@loomcore/common/utils';
+import { BadRequestError } from '../../../errors/index.js';
+import NoSqlPipeline from '../models/no-sql-pipeline.js';
 export async function getById(db, operations, queryObject, id, pluralResourceName) {
     if (!entityUtils.isValidObjectId(id)) {
         throw new BadRequestError('id is not a valid ObjectId');

package/dist/databases/mongo-db/queries/mongo-get-count.query.d.ts

@@ -1,2 +1,2 @@
-import { Db } from "mongodb";
+import { Db } from 'mongodb';
 export declare function getCount(db: Db, pluralResourceName: string): Promise<number>;

package/dist/databases/mongo-db/queries/mongo-get.query.d.ts

@@ -1,4 +1,4 @@
-import { Db } from "mongodb";
-import { IModelSpec, IQueryOptions, IPagedResult } from "@loomcore/common/models";
-import { Operation } from "../../operations/operation.js";
+import { Db } from 'mongodb';
+import { IModelSpec, IQueryOptions, IPagedResult } from '@loomcore/common/models';
+import { Operation } from '../../operations/operation.js';
 export declare function get<T>(db: Db, operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;

package/dist/databases/mongo-db/queries/mongo-get.query.js

@@ -1,5 +1,5 @@
-import NoSqlPipeline from "../models/no-sql-pipeline.js";
-import { apiUtils } from "../../../utils/api.utils.js";
+import NoSqlPipeline from '../models/no-sql-pipeline.js';
+import { apiUtils } from '../../../utils/api.utils.js';
 export async function get(db, operations, queryOptions, modelSpec, pluralResourceName) {
     const collection = db.collection(pluralResourceName);
     const pipeline = new NoSqlPipeline()