@loomcore/api 0.2.7 → 0.2.9

package/dist/controllers/auth.controller.js

@@ -1,60 +1,76 @@
-import { LoginResponseSpec, PublicUserContextSpec, PublicUserSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
+import { EmptyUserContext, LoginResponseSpec, PublicUserContextSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
 import { entityUtils } from "@loomcore/common/utils";
+import { config } from "../config/base-api-config.js";
 import { BadRequestError, UnauthenticatedError } from "../errors/index.js";
 import { isAuthorized } from "../middleware/index.js";
-import { AuthService } from "../services/index.js";
+import { OrganizationService, UserService } from "../services/index.js";
+import { attemptLogin, changePassword, getAndSetDeviceIdCookie, getDeviceIdFromCookie, requestTokenUsingRefreshToken, resetPassword, sendResetPasswordEmail, } from "../utils/auth/index.js";
 import { apiUtils } from "../utils/index.js";
 export class AuthController {
-    authService;
+    database;
+    userService;
+    organizationService;
     constructor(app, database) {
-        this.authService = new AuthService(database);
+        this.database = database;
+        this.userService = new UserService(database);
+        this.organizationService = new OrganizationService(database);
         this.mapRoutes(app);
     }
     mapRoutes(app) {
         app.post(`/api/auth/login`, this.login.bind(this), this.afterAuth.bind(this));
-        app.post(`/api/auth/register`, isAuthorized(), this.registerUser.bind(this));
         app.get(`/api/auth/refresh`, this.requestTokenUsingRefreshToken.bind(this));
         app.get(`/api/auth/get-user-context`, isAuthorized(), this.getUserContext.bind(this));
         app.patch(`/api/auth/change-password`, isAuthorized(), this.changePassword.bind(this));
         app.post(`/api/auth/forgot-password`, this.forgotPassword.bind(this));
         app.post(`/api/auth/reset-password`, this.resetPassword.bind(this));
     }
-    async login(req, res, next) {
+    async login(req, res) {
         const { email, password } = req.body;
+        if (!email || typeof email !== "string") {
+            throw new BadRequestError("Missing required fields: email is required.");
+        }
+        if (!password || typeof password !== "string") {
+            throw new BadRequestError("Missing required fields: password is required.");
+        }
+        let organization = null;
+        if (config.app.isMultiTenant) {
+            const referer = req.get("referer") || req.headers.referer;
+            if (!referer) {
+                throw new BadRequestError("Missing required fields: referer is required.");
+            }
+            organization = await this.organizationService.findOne(EmptyUserContext, {
+                filters: { domain: { eq: referer.split("/")[2] } },
+            });
+            if (!organization) {
+                throw new BadRequestError("Missing required fields: organization is required.");
+            }
+        }
         res.set("Content-Type", "application/json");
-        const loginResponse = await this.authService.attemptLogin(req, res, email, password);
+        const deviceId = getAndSetDeviceIdCookie(req, res);
+        const loginResponse = await attemptLogin(this.database, email, password, deviceId, organization);
         apiUtils.apiResponse(res, 200, { data: loginResponse }, LoginResponseSpec);
     }
-    async registerUser(req, res) {
+    async requestTokenUsingRefreshToken(req, res) {
         const userContext = req.userContext;
         if (!userContext) {
             throw new BadRequestError("Missing required fields: userContext is required.");
         }
-        const body = req.body;
-        const validationErrors = this.authService.validate(body.user);
-        entityUtils.handleValidationResult(validationErrors, "AuthController.registerUser");
-        const user = await this.authService.createUser(userContext, body.user);
-        apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSpec);
-    }
-    async requestTokenUsingRefreshToken(req, res, next) {
         const refreshToken = req.query.refreshToken;
         if (!refreshToken || typeof refreshToken !== "string") {
             throw new BadRequestError("Missing required fields: refreshToken is required.");
         }
-        const deviceId = this.authService.getDeviceIdFromCookie(req);
-        const tokens = await this.authService.requestTokenUsingRefreshToken(refreshToken, deviceId);
-        if (tokens) {
-            apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
-        }
-        else {
+        const deviceId = getDeviceIdFromCookie(req);
+        const tokens = await requestTokenUsingRefreshToken(this.database, userContext, refreshToken, deviceId);
+        if (!tokens) {
             throw new UnauthenticatedError();
         }
+        apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
     }
-    async getUserContext(req, res, next) {
+    async getUserContext(req, res) {
         const userContext = req.userContext;
         apiUtils.apiResponse(res, 200, { data: userContext }, PublicUserContextSpec);
     }
-    afterAuth(req, res, loginResponse) {
+    afterAuth(_req, _res, _loginResponse) {
         console.log("in afterAuth");
     }
     async changePassword(req, res) {
@@ -62,22 +78,40 @@ export class AuthController {
         if (!userContext) {
             throw new BadRequestError("Missing required fields: userContext is required.");
         }
-        const body = req.body;
-        const validationErrors = entityUtils.validate(UserSpec, { password: body.password }, true, passwordValidator);
+        const password = req.body?.password;
+        const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
         entityUtils.handleValidationResult(validationErrors, "AuthController.changePassword");
-        const updateResult = await this.authService.changeLoggedInUsersPassword(userContext, body);
+        const updateResult = await changePassword(this.database, userContext, password);
         apiUtils.apiResponse(res, 200, { data: updateResult });
     }
     async forgotPassword(req, res) {
         const email = req.body?.email;
+        if (!email || typeof email !== "string") {
+            throw new BadRequestError("Missing required fields: email is required.");
+        }
         let referer = req.get("referer") || req.headers.referer;
         if (!referer) {
             throw new BadRequestError("Missing required fields: referer is required.");
         }
         referer = referer.replace(/\/$/, "");
-        const user = await this.authService.getUserByEmail(email);
+        let organization = null;
+        if (config.app.isMultiTenant) {
+            organization = await this.organizationService.findOne(EmptyUserContext, {
+                filters: { domain: { eq: referer.split("/")[2] } },
+            });
+            if (!organization) {
+                throw new BadRequestError("Missing required fields: organization is required.");
+            }
+        }
+        const userContext = {
+            ...EmptyUserContext,
+            organization: organization || undefined,
+        };
+        const user = await this.userService.findOne(userContext, {
+            filters: { email: { eq: email.toLowerCase() } },
+        });
         if (user) {
-            await this.authService.sendResetPasswordEmail(email, referer);
+            await sendResetPasswordEmail(this.database, email, referer);
         }
         apiUtils.apiResponse(res, 200);
     }
@@ -86,7 +120,20 @@ export class AuthController {
         if (!email || !token || !password) {
             throw new BadRequestError("Missing required fields: email, token, and password are required.");
         }
-        const response = await this.authService.resetPassword(email, token, password);
+        let organization = null;
+        if (config.app.isMultiTenant) {
+            const referer = req.get("referer") || req.headers.referer;
+            if (!referer) {
+                throw new BadRequestError("Missing required fields: referer is required.");
+            }
+            organization = await this.organizationService.findOne(EmptyUserContext, {
+                filters: { domain: { eq: referer.split("/")[2] } },
+            });
+            if (!organization) {
+                throw new BadRequestError("Missing required fields: organization is required.");
+            }
+        }
+        const response = await resetPassword(this.database, email, token, password, organization);
         apiUtils.apiResponse(res, 200, { data: response });
     }
 }

package/dist/controllers/authorizations.controller.d.ts

@@ -1,7 +1,7 @@
-import { IAuthorization } from "../models/authorization.model.js";
+import type { Application } from "express";
+import type { IDatabase } from "../databases/models/index.js";
+import { type IAuthorization } from "../models/authorization.model.js";
 import { ApiController } from "./api.controller.js";
-import { Application } from "express";
-import { IDatabase } from "../databases/models/index.js";
 export declare class AuthorizationsController extends ApiController<IAuthorization> {
     constructor(app: Application, database: IDatabase);
 }

package/dist/controllers/authorizations.controller.js

@@ -1,9 +1,9 @@
-import { AuthorizationModelSpec } from "../models/authorization.model.js";
-import { ApiController } from "./api.controller.js";
+import { AuthorizationModelSpec, } from "../models/authorization.model.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import { ApiController } from "./api.controller.js";
 export class AuthorizationsController extends ApiController {
     constructor(app, database) {
-        const authorizationService = new MultiTenantApiService(database, 'authorizations', 'authorization', AuthorizationModelSpec);
-        super('authorizations', app, authorizationService, 'authorization', AuthorizationModelSpec);
+        const authorizationService = new MultiTenantApiService(database, "authorizations", "authorization", AuthorizationModelSpec);
+        super("authorizations", app, authorizationService, "authorization", AuthorizationModelSpec);
     }
 }

package/dist/controllers/roles.controller.d.ts

@@ -1,7 +1,7 @@
+import { Application } from "express";
 import { IDatabase } from "../databases/models/index.js";
 import { IRole } from "../models/role.model.js";
 import { ApiController } from "./api.controller.js";
-import { Application } from "express";
 export declare class RolesController extends ApiController<IRole> {
     constructor(app: Application, database: IDatabase);
 }

package/dist/controllers/roles.controller.js

@@ -1,9 +1,9 @@
 import { RoleModelSpec } from "../models/role.model.js";
-import { ApiController } from "./api.controller.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import { ApiController } from "./api.controller.js";
 export class RolesController extends ApiController {
     constructor(app, database) {
-        const roleService = new MultiTenantApiService(database, 'roles', 'role', RoleModelSpec);
-        super('roles', app, roleService, 'role', RoleModelSpec, RoleModelSpec);
+        const roleService = new MultiTenantApiService(database, "roles", "role", RoleModelSpec);
+        super("roles", app, roleService, "role", RoleModelSpec, RoleModelSpec);
     }
 }

package/dist/controllers/users.controller.d.ts

@@ -1,10 +1,9 @@
-import { Application } from 'express';
-import { IUser } from '@loomcore/common/models';
-import { ApiController } from './api.controller.js';
-import { UserService } from '../services/index.js';
-import { IDatabase } from '../databases/models/index.js';
+import { type IUser } from "@loomcore/common/models";
+import type { Application } from "express";
+import type { IDatabase } from "../databases/models/index.js";
+import { UserService } from "../services/index.js";
+import { ApiController } from "./api.controller.js";
 export declare class UsersController extends ApiController<IUser> {
     userService: UserService;
     constructor(app: Application, database: IDatabase);
-    mapRoutes(app: Application): void;
 }

package/dist/controllers/users.controller.js

@@ -1,22 +1,11 @@
-import { UserSpec, PublicUserSpec } from '@loomcore/common/models';
-import { ApiController } from './api.controller.js';
-import { isAuthorized } from '../middleware/index.js';
-import { UserService } from '../services/index.js';
+import { PublicUserSpec, UserSpec } from "@loomcore/common/models";
+import { UserService } from "../services/index.js";
+import { ApiController } from "./api.controller.js";
 export class UsersController extends ApiController {
     userService;
     constructor(app, database) {
         const userService = new UserService(database);
-        super('users', app, userService, 'user', UserSpec, PublicUserSpec);
+        super("users", app, userService, "user", UserSpec, PublicUserSpec);
         this.userService = userService;
     }
-    mapRoutes(app) {
-        app.get(`/api/${this.slug}`, isAuthorized(), this.get.bind(this));
-        app.get(`/api/${this.slug}/all`, isAuthorized(), this.getAll.bind(this));
-        app.get(`/api/${this.slug}/find`, isAuthorized(), this.get.bind(this));
-        app.get(`/api/${this.slug}/count`, isAuthorized(), this.getCount.bind(this));
-        app.get(`/api/${this.slug}/:id`, isAuthorized(), this.getById.bind(this));
-        app.post(`/api/${this.slug}`, isAuthorized(), this.create.bind(this));
-        app.patch(`/api/${this.slug}/:id`, isAuthorized(), this.partialUpdateById.bind(this));
-        app.delete(`/api/${this.slug}/:id`, isAuthorized(), this.deleteById.bind(this));
-    }
 }

package/dist/databases/postgres/commands/postgres-create.command.d.ts

@@ -1,6 +1,6 @@
-import type { PostgresConnection } from '../postgres-connection.js';
-import { IEntity } from "@loomcore/common/models";
+import type { IEntity } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
+import type { PostgresConnection } from "../postgres-connection.js";
 export declare function create<T extends IEntity>(client: PostgresConnection, pluralResourceName: string, entity: Partial<T>): Promise<{
     insertedId: AppIdType;
     entity: T;

package/dist/databases/postgres/commands/postgres-create.command.js

@@ -1,12 +1,12 @@
 import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
-import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
+import { columnsAndValuesFromEntity } from "../utils/columns-and-values-from-entity.js";
 export async function create(client, pluralResourceName, entity) {
     try {
         delete entity._id;
         const { columns, values } = columnsAndValuesFromEntity(entity);
-        const placeholders = columns.map((_, index) => `$${index + 1}`).join(', ');
+        const placeholders = columns.map((_, index) => `$${index + 1}`).join(", ");
         const query = `
-            INSERT INTO "${pluralResourceName}" (${columns.join(', ')})
+            INSERT INTO "${pluralResourceName}" (${columns.join(", ")})
             VALUES (${placeholders})
             RETURNING *
         `;
@@ -18,11 +18,11 @@ export async function create(client, pluralResourceName, entity) {
         const insertedId = insertedRow._id;
         return {
             insertedId: insertedId,
-            entity: insertedRow
+            entity: insertedRow,
         };
     }
     catch (err) {
-        if (err.code === '23505') {
+        if (err.code === "23505") {
             throw new DuplicateKeyError(`${pluralResourceName} already exists`);
         }
         throw new BadRequestError(`Error creating ${pluralResourceName}: ${err.message}`);

package/dist/databases/postgres/migrations/__tests__/test-migration-helper.js

@@ -1,4 +1,5 @@
 import { Umzug } from 'umzug';
+import { TEST_META_ORG_DOMAIN } from '../../../../__tests__/test-objects.js';
 import { getPostgresInitialSchema } from '../postgres-initial-schema.js';
 import { getPostgresTestSchema } from '../../../../__tests__/postgres-test-migrations/postgres-test-schema.js';
 export async function runInitialSchemaMigrations(pool, config) {
@@ -7,7 +8,7 @@ export async function runInitialSchemaMigrations(pool, config) {
         app: config.app,
         database: config.database,
         adminUser: config.adminUser ?? { email: 'admin@test.com', password: 'admin-password' },
-        multiTenant: config.multiTenant ?? (config.app.isMultiTenant ? { metaOrgName: 'Test Meta Organization', metaOrgCode: 'TEST_META_ORG' } : { metaOrgName: '', metaOrgCode: '' }),
+        multiTenant: config.multiTenant ?? (config.app.isMultiTenant ? { metaOrgName: 'Test Meta Organization', metaOrgCode: 'TEST_META_ORG', metaOrgDomain: TEST_META_ORG_DOMAIN } : { metaOrgName: '', metaOrgCode: '', metaOrgDomain: '' }),
         email: config.email,
     };
     const initialSchema = getPostgresInitialSchema(migrationConfig);

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -33,7 +33,8 @@ export const getPostgresInitialSchema = (dbConfig) => {
           CREATE TABLE IF NOT EXISTS "organizations" (
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
             "name" VARCHAR(255) NOT NULL UNIQUE,
-            "code" VARCHAR(255) NOT NULL UNIQUE,
+            "code" VARCHAR(255) UNIQUE,
+			"domain" VARCHAR(255) UNIQUE,
             "description" TEXT,
             "status" INTEGER NOT NULL,
             "is_meta_org" BOOLEAN NOT NULL,
@@ -297,12 +298,13 @@ export const getPostgresInitialSchema = (dbConfig) => {
             name: "00000000000011_data-meta-org",
             up: async ({ context: pool }) => {
                 const result = await pool.query(`
-          INSERT INTO "organizations"("name", "code", "status", "is_meta_org", "_created", "_createdBy")
-        VALUES($1, $2, 1, true, NOW(), 0)
-          RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy"
-          `, [
+					INSERT INTO "organizations"("name", "code", "domain", "status", "is_meta_org", "_created", "_createdBy")
+					VALUES($1, $2, $3, 1, true, NOW(), 0)
+					RETURNING "_id", "name", "code", "domain", "status", "is_meta_org", "_created", "_createdBy"
+					`, [
                     dbConfig.multiTenant?.metaOrgName,
                     dbConfig.multiTenant?.metaOrgCode,
+                    dbConfig.multiTenant?.metaOrgDomain,
                 ]);
                 if (result.rowCount === 0) {
                     throw new Error("Failed to create meta organization");

package/dist/databases/postgres/postgres.database.d.ts

@@ -1,9 +1,9 @@
-import { IQueryOptions, IModelSpec, IPagedResult, IEntity, IUserContextAuthorization } from "@loomcore/common/models";
+import { IEntity, IModelSpec, IPagedResult, IQueryOptions, IUserContextAuthorization } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
 import { TSchema } from "@sinclair/typebox";
 import { DeleteResult, IDatabase } from "../models/index.js";
 import { Operation } from "../operations/operation.js";
-import type { PostgresConnection } from './postgres-connection.js';
+import type { PostgresConnection } from "./postgres-connection.js";
 export declare class PostgresDatabase implements IDatabase {
     private connection;
     constructor(connection: PostgresConnection);

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

@@ -1,19 +1,19 @@
+import { batchUpdate as batchUpdateCommand } from "./commands/postgres-batch-update.command.js";
 import { create as createCommand } from "./commands/postgres-create.command.js";
 import { createMany as createManyCommand } from "./commands/postgres-create-many.command.js";
-import { batchUpdate as batchUpdateCommand } from "./commands/postgres-batch-update.command.js";
+import { deleteById as deleteByIdCommand } from "./commands/postgres-delete-by-id.command.js";
+import { deleteMany as deleteManyCommand } from "./commands/postgres-delete-many.command.js";
 import { fullUpdateById as fullUpdateByIdCommand } from "./commands/postgres-full-update-by-id.command.js";
 import { partialUpdateById as partialUpdateByIdCommand } from "./commands/postgres-partial-update-by-id.command.js";
 import { update as updateCommand } from "./commands/postgres-update.command.js";
-import { deleteById as deleteByIdCommand } from "./commands/postgres-delete-by-id.command.js";
-import { deleteMany as deleteManyCommand } from "./commands/postgres-delete-many.command.js";
-import { findOne as findOneQuery } from "./queries/postgres-find-one.query.js";
 import { find as findQuery } from "./queries/postgres-find.query.js";
-import { getAll as getAllQuery } from "./queries/postgres-get-all.query.js";
+import { findOne as findOneQuery } from "./queries/postgres-find-one.query.js";
 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 { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
-import { convertKeysToSnakeCase, convertKeysToCamelCase } from "./utils/convert-keys.util.js";
 export class PostgresDatabase {
     connection;
     constructor(connection) {
@@ -72,7 +72,6 @@ export class PostgresDatabase {
         const now = new Date();
         let query = `
             SELECT DISTINCT
-                ur."user_id" as "userId",
                 r."name" as "role",
                 f."name" as "feature",
                 a."config",
@@ -96,7 +95,6 @@ export class PostgresDatabase {
         const result = await this.connection.query(query, values);
         const authorizations = [];
         for (const row of result.rows) {
-            const userId = row.userId;
             authorizations.push({
                 _id: row._id,
                 _orgId: row._orgId,

package/dist/middleware/index.d.ts

@@ -1,4 +1,4 @@
-export * from './error-handler.js';
-export * from './is-authorized.js';
-export * from './ensure-user-context.js';
-export * from './request-lifecycle.js';
+export * from "./ensure-user-context.js";
+export * from "./error-handler.js";
+export * from "./is-authorized.js";
+export * from "./request-lifecycle.js";

package/dist/middleware/index.js

@@ -1,4 +1,4 @@
-export * from './error-handler.js';
-export * from './is-authorized.js';
-export * from './ensure-user-context.js';
-export * from './request-lifecycle.js';
+export * from "./ensure-user-context.js";
+export * from "./error-handler.js";
+export * from "./is-authorized.js";
+export * from "./request-lifecycle.js";

package/dist/middleware/is-authorized.d.ts

@@ -1,3 +1,3 @@
-import { Request, Response, NextFunction } from 'express';
-declare const isAuthorized: (allowedFeatures?: string[]) => (req: Request, res: Response, next: NextFunction) => void;
+import type { NextFunction, Request, Response } from "express";
+declare const isAuthorized: (allowedFeatures?: string[]) => (req: Request, _res: Response, next: NextFunction) => void;
 export { isAuthorized };

package/dist/middleware/is-authorized.js

@@ -1,13 +1,13 @@
-import { UserContextSpec } from '@loomcore/common/models';
-import { UnauthenticatedError, UnauthorizedError } from '../errors/index.js';
-import { JwtService } from '../services/index.js';
-import { config } from '../config/index.js';
+import { UserContextSpec } from "@loomcore/common/models";
+import jwt from "jsonwebtoken";
+import { UnauthenticatedError, UnauthorizedError } from "../errors/index.js";
+import { getAuthConfig } from "../utils/auth/get-auth-config.util.js";
 const isAuthorized = (allowedFeatures) => {
-    return (req, res, next) => {
+    return (req, _res, next) => {
         let token = null;
         if (req.headers?.authorization) {
-            let authHeader = req.headers.authorization;
-            const authHeaderArray = authHeader.split('Bearer ');
+            const authHeader = req.headers.authorization;
+            const authHeaderArray = authHeader.split("Bearer ");
             if (authHeaderArray?.length > 1) {
                 token = authHeaderArray[1];
             }
@@ -15,15 +15,16 @@ const isAuthorized = (allowedFeatures) => {
         if (!token) {
             throw new UnauthenticatedError();
         }
+        const authConfig = getAuthConfig();
         try {
-            const rawPayload = JwtService.verify(token, config.auth?.clientSecret || '');
+            const rawPayload = jwt.verify(token, authConfig.clientSecret);
             const userContext = UserContextSpec.decode(rawPayload);
             req.userContext = userContext;
-            if (userContext.authorizations.some(authorization => authorization.feature === 'admin')) {
+            if (userContext.authorizations.some((authorization) => authorization.feature === "admin")) {
                 next();
             }
-            else if (allowedFeatures && allowedFeatures.length) {
-                if (!userContext.authorizations.some(authorization => allowedFeatures?.includes(authorization.feature))) {
+            else if (allowedFeatures?.length) {
+                if (!userContext.authorizations.some((authorization) => allowedFeatures.includes(authorization.feature))) {
                     throw new UnauthorizedError();
                 }
                 next();
@@ -33,6 +34,7 @@ const isAuthorized = (allowedFeatures) => {
             }
         }
         catch (err) {
+            console.error(err);
             throw new UnauthenticatedError();
         }
     };

package/dist/models/app-config.interface.d.ts

@@ -1,4 +1,4 @@
-import { DbType } from "../databases/db-type.type.js";
+import type { DbType } from "../databases/db-type.type.js";
 export interface IAppConfig {
     dbType: DbType;
     isMultiTenant: boolean;

package/dist/models/base-api-config.interface.d.ts

@@ -1,8 +1,8 @@
-import { IAppConfig } from "./app-config.interface.js";
-import { IAuthConfig } from "./auth-config.interface.js";
-import { IDatabaseConfig } from "./database-config.interface.js";
-import { IEmailConfig } from "./email-config.interface.js";
-import { IEmailClient } from "./email-client.interface.js";
+import type { IAppConfig } from "./app-config.interface.js";
+import type { IAuthConfig } from "./auth-config.interface.js";
+import type { IDatabaseConfig } from "./database-config.interface.js";
+import type { IEmailClient } from "./email-client.interface.js";
+import type { IEmailConfig } from "./email-config.interface.js";
 export interface IBaseApiConfig {
     app: IAppConfig;
     auth?: IAuthConfig;

package/dist/models/initial-database-config.interface.d.ts

@@ -1,6 +1,6 @@
-import { IAppConfig } from "./app-config.interface.js";
-import { IDatabaseConfig } from "./database-config.interface.js";
-import { IEmailConfig } from "./email-config.interface.js";
+import type { IAppConfig } from "./app-config.interface.js";
+import type { IDatabaseConfig } from "./database-config.interface.js";
+import type { IEmailConfig } from "./email-config.interface.js";
 export interface IInitialDbMigrationConfig {
     env: string;
     app: IAppConfig;
@@ -12,6 +12,7 @@ export interface IInitialDbMigrationConfig {
     multiTenant: {
         metaOrgName: string;
         metaOrgCode: string;
+        metaOrgDomain: string;
     };
     email?: IEmailConfig;
 }

package/dist/models/refresh-token.model.d.ts

@@ -1,4 +1,4 @@
-import { IEntity } from "@loomcore/common/models";
+import type { IEntity } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
 export interface IRefreshToken extends IEntity {
     token: string;

package/dist/models/refresh-token.model.js

@@ -1,13 +1,12 @@
 import { entityUtils } from "@loomcore/common/utils";
-import { TypeboxIsoDate, getIdSchema } from "@loomcore/common/validation";
+import { getIdSchema, TypeboxIsoDate } from "@loomcore/common/validation";
 import { Type } from "@sinclair/typebox";
-;
 export const refreshTokenSchema = Type.Object({
     token: Type.String({ minLength: 1 }),
     deviceId: Type.String({ minLength: 1 }),
     userId: getIdSchema(),
     expiresOn: Type.Number(),
-    created: TypeboxIsoDate({ title: 'Created Date' }),
-    createdBy: getIdSchema()
+    created: TypeboxIsoDate({ title: "Created Date" }),
+    createdBy: getIdSchema(),
 });
 export const refreshTokenModelSpec = entityUtils.getModelSpec(refreshTokenSchema);

package/dist/services/generic-api-service/generic-api-service.interface.d.ts

@@ -1,9 +1,9 @@
-import { ValueError } from '@sinclair/typebox/errors';
-import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/common/models';
-import type { AppIdType } from '@loomcore/common/types';
-import { DeleteResult } from '../../databases/models/delete-result.js';
-import { Operation } from '../../databases/operations/operation.js';
-import { PostProcessEntityCustomFunction, PrepareQueryCustomFunction } from '../../controllers/types.js';
+import type { IEntity, IPagedResult, IQueryOptions, IUserContext } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
+import type { ValueError } from "@sinclair/typebox/errors";
+import type { PostProcessEntityCustomFunction, PrepareQueryCustomFunction } from "../../controllers/types.js";
+import type { DeleteResult } from "../../databases/models/delete-result.js";
+import type { Operation } from "../../databases/operations/operation.js";
 export interface IGenericApiService<T extends IEntity> {
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;

package/dist/services/generic-api-service/generic-api.service.d.ts

@@ -1,11 +1,11 @@
-import { ValueError } from '@sinclair/typebox/errors';
-import { IUserContext, IEntity, IQueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
-import type { AppIdType } from '@loomcore/common/types';
-import { IGenericApiService } from './generic-api-service.interface.js';
-import { Operation } from '../../databases/operations/operation.js';
-import { DeleteResult } from '../../databases/models/delete-result.js';
-import { IDatabase } from '../../databases/models/index.js';
-import { PostProcessEntityCustomFunction, PrepareQueryCustomFunction } from '../../controllers/types.js';
+import { type IEntity, type IModelSpec, type IPagedResult, type IQueryOptions, type IUserContext } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
+import type { ValueError } from "@sinclair/typebox/errors";
+import type { PostProcessEntityCustomFunction, PrepareQueryCustomFunction } from "../../controllers/types.js";
+import type { DeleteResult } from "../../databases/models/delete-result.js";
+import type { IDatabase } from "../../databases/models/index.js";
+import type { Operation } from "../../databases/operations/operation.js";
+import type { IGenericApiService } from "./generic-api-service.interface.js";
 export declare class GenericApiService<T extends IEntity> implements IGenericApiService<T> {
     protected database: IDatabase;
     protected pluralResourceName: string;