@devxcrew/platform 0.1.2 → 0.1.6

package/dist/modules/identity/user-role/user-role.seed.d.ts

@@ -0,0 +1,7 @@
+import type { Transaction } from "kysely";
+import type { IdentitySchema, Portal } from "../identity.types.js";
+export declare function seedMemberships(trx: Transaction<IdentitySchema>, created: Array<{
+    userId: string;
+    tenantId: string;
+    portal: Portal;
+}>): Promise<void>;

package/dist/modules/identity/user-role/user-role.seed.js

@@ -0,0 +1,11 @@
+export async function seedMemberships(trx, created) {
+    for (const account of created)
+        await trx
+            .insertInto("identity_memberships")
+            .values({
+            user_id: account.userId,
+            tenant_id: account.tenantId,
+            role_id: account.portal
+        })
+            .execute();
+}

package/dist/modules/identity/user-role/user-role.service.d.ts

@@ -0,0 +1,60 @@
+import type { Kysely, Transaction } from "kysely";
+import type { IdentitySchema, Portal, Principal } from "../identity.types.js";
+import type { IdentityRoleResolver } from "../role/index.js";
+import type { IdentityMutation } from "../identity.types.js";
+import { type MembershipReadSources } from "./user-role.repository.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+export declare class IdentityUserRoleService {
+    private readonly db;
+    private readonly readSources;
+    private readonly activeUsers;
+    private readonly resolveRole;
+    private readonly customRoleInApp;
+    private readonly mutate;
+    private readonly assertUserVisible;
+    private readonly activeOrganization;
+    private readonly recordAudit;
+    private readonly revokeMembershipSessions;
+    constructor(db: Kysely<IdentitySchema>, readSources: MembershipReadSources, activeUsers: (db: Kysely<IdentitySchema>, ids: string[]) => Promise<string[]>, resolveRole: IdentityRoleResolver, customRoleInApp: (db: Kysely<IdentitySchema>, id: string, appId: string) => Promise<unknown>, mutate: IdentityMutation, assertUserVisible: (actor: Principal, userId: string) => Promise<unknown>, activeOrganization: (trx: Transaction<IdentitySchema>, id: string) => Promise<unknown>, recordAudit: (trx: Transaction<IdentitySchema>, actor: Principal, tenantId: string, action: string, id: string) => Promise<void>, revokeMembershipSessions: (trx: Transaction<IdentitySchema>, appId: string, userId: string, tenantId: string, portal: Portal) => Promise<void>);
+    list(actor: Principal, query: IdentityListQuery): Promise<{
+        data: {
+            active: boolean;
+            version: number;
+        }[];
+        meta: {
+            page: number;
+            perPage: number;
+            total: number;
+            lastPage: number;
+        };
+    }>;
+    show(actor: Principal, id: string): Promise<{
+        active: boolean;
+        version: number;
+    } | undefined>;
+    createMembership(actor: Principal, raw: unknown): Promise<{
+        id: string;
+        userId: string;
+        tenantId: string;
+        roleId: string;
+        portal: Portal;
+        active: boolean;
+        version: number;
+    }>;
+    assignInitialMembership(trx: Transaction<IdentitySchema>, actor: Principal, userId: string, tenantId: string, roleId: string): Promise<void>;
+    updateMembership(actor: Principal, id: string, raw: unknown): Promise<{
+        id: string;
+        userId: string;
+        tenantId: string;
+        roleId: string;
+        portal: Portal;
+        active: boolean;
+        version: number;
+    }>;
+    removeMembership(actor: Principal, id: string, expectedVersion?: number): Promise<void>;
+    private manage;
+    private scope;
+    private tenantId;
+    private activeTenant;
+    private audit;
+}

package/dist/modules/identity/user-role/user-role.service.js

@@ -0,0 +1,216 @@
+import { IdentityError } from "../support/identity.error.js";
+import { checkIdentityRequest } from "../support/identity.request-context.js";
+import { protectAdministrators } from "./user-role.policy.js";
+import { membershipSchema, membershipUpdateSchema } from "./user-role.schema.js";
+import { listMemberships, showMembership } from "./user-role.repository.js";
+export class IdentityUserRoleService {
+    db;
+    readSources;
+    activeUsers;
+    resolveRole;
+    customRoleInApp;
+    mutate;
+    assertUserVisible;
+    activeOrganization;
+    recordAudit;
+    revokeMembershipSessions;
+    constructor(db, readSources, activeUsers, resolveRole, customRoleInApp, mutate, assertUserVisible, activeOrganization, recordAudit, revokeMembershipSessions) {
+        this.db = db;
+        this.readSources = readSources;
+        this.activeUsers = activeUsers;
+        this.resolveRole = resolveRole;
+        this.customRoleInApp = customRoleInApp;
+        this.mutate = mutate;
+        this.assertUserVisible = assertUserVisible;
+        this.activeOrganization = activeOrganization;
+        this.recordAudit = recordAudit;
+        this.revokeMembershipSessions = revokeMembershipSessions;
+    }
+    list(actor, query) {
+        this.manage(actor);
+        return listMemberships(this.db, actor, query, this.readSources);
+    }
+    show(actor, id) {
+        this.manage(actor);
+        return showMembership(this.db, actor, id, this.readSources);
+    }
+    async createMembership(actor, raw) {
+        this.manage(actor);
+        const input = membershipSchema.parse(raw);
+        const tenantId = this.tenantId(actor, input.tenantId);
+        const selected = await this.resolveRole(this.db, actor, input.roleId, tenantId);
+        await this.assertUserVisible(actor, input.userId);
+        const id = `${input.userId}~${tenantId}~${selected.portal}`;
+        return this.mutate(actor, "memberships", id, async (trx) => {
+            await this.activeTenant(trx, tenantId);
+            const currentRole = await this.resolveRole(trx, actor, input.roleId, tenantId);
+            if (await trx
+                .selectFrom("identity_memberships")
+                .select("user_id")
+                .where("user_id", "=", input.userId)
+                .where("tenant_id", "=", tenantId)
+                .where("role_id", "=", currentRole.portal)
+                .executeTakeFirst())
+                throw new IdentityError(409, "Membership already exists.");
+            await trx
+                .insertInto("identity_memberships")
+                .values({
+                user_id: input.userId,
+                tenant_id: tenantId,
+                role_id: currentRole.portal,
+                custom_role_id: currentRole.customRoleId
+            })
+                .execute();
+            return {
+                id,
+                userId: input.userId,
+                tenantId,
+                roleId: input.roleId,
+                portal: currentRole.portal,
+                active: true,
+                version: 0
+            };
+        });
+    }
+    async assignInitialMembership(trx, actor, userId, tenantId, roleId) {
+        this.manage(actor);
+        this.tenantId(actor, tenantId);
+        await this.activeTenant(trx, tenantId);
+        const selected = await this.resolveRole(trx, actor, roleId, tenantId);
+        await trx
+            .insertInto("identity_memberships")
+            .values({
+            user_id: userId,
+            tenant_id: tenantId,
+            role_id: selected.portal,
+            custom_role_id: selected.customRoleId
+        })
+            .execute();
+    }
+    async updateMembership(actor, id, raw) {
+        this.manage(actor);
+        const input = membershipUpdateSchema.parse(raw);
+        const [userId, tenantId, oldPortal, extra] = id.split("~");
+        if (!userId || !tenantId || !oldPortal || extra)
+            throw new IdentityError(404, "Membership not found.");
+        this.scope(actor, tenantId);
+        if (actor.portal !== "super-admin" && oldPortal !== "user")
+            throw new IdentityError(403, "Only super administrators can change privileged memberships.");
+        return this.db.transaction().execute(async (trx) => {
+            checkIdentityRequest();
+            const current = await trx
+                .selectFrom("identity_memberships")
+                .selectAll()
+                .where("user_id", "=", userId)
+                .where("tenant_id", "=", tenantId)
+                .where("role_id", "=", oldPortal)
+                .executeTakeFirst();
+            if (!current)
+                throw new IdentityError(404, "Membership not found.");
+            if (current.custom_role_id &&
+                !(await this.customRoleInApp(trx, current.custom_role_id, actor.appId)))
+                throw new IdentityError(404, "Membership not found.");
+            if (input.active && !(await this.activeOrganization(trx, tenantId)))
+                throw new IdentityError(422, "Organization is inactive or unavailable.");
+            if (Number(current.version) !== input.expectedVersion)
+                throw new IdentityError(409, "This record changed. Reload before saving.");
+            const selected = await this.resolveRole(trx, actor, input.roleId, tenantId);
+            if (!input.active || selected.portal !== oldPortal)
+                await protectAdministrators(trx, userId, this.activeUsers, tenantId, oldPortal);
+            if (selected.portal !== oldPortal &&
+                (await trx
+                    .selectFrom("identity_memberships")
+                    .select("user_id")
+                    .where("user_id", "=", userId)
+                    .where("tenant_id", "=", tenantId)
+                    .where("role_id", "=", selected.portal)
+                    .executeTakeFirst()))
+                throw new IdentityError(409, "This account already has that portal membership.");
+            const changed = await trx
+                .updateTable("identity_memberships")
+                .set({
+                role_id: selected.portal,
+                custom_role_id: selected.customRoleId,
+                active: Number(input.active),
+                version: input.expectedVersion + 1
+            })
+                .where("user_id", "=", userId)
+                .where("tenant_id", "=", tenantId)
+                .where("role_id", "=", oldPortal)
+                .where("version", "=", input.expectedVersion)
+                .executeTakeFirst();
+            if (changed.numUpdatedRows !== 1n)
+                throw new IdentityError(409, "This record changed. Reload before saving.");
+            await this.revokeMembershipSessions(trx, actor.appId, userId, tenantId, oldPortal);
+            const nextId = `${userId}~${tenantId}~${selected.portal}`;
+            await this.audit(trx, actor, tenantId, "identity.membership.changed", nextId);
+            checkIdentityRequest();
+            return {
+                id: nextId,
+                userId,
+                tenantId,
+                roleId: selected.customRoleId ?? selected.portal,
+                portal: selected.portal,
+                active: input.active,
+                version: input.expectedVersion + 1
+            };
+        });
+    }
+    async removeMembership(actor, id, expectedVersion) {
+        this.manage(actor);
+        if (!Number.isInteger(expectedVersion) || Number(expectedVersion) < 0)
+            throw new IdentityError(422, "Provide the current membership version.");
+        const [userId, tenantId, portal, extra] = id.split("~");
+        if (!userId || !tenantId || !portal || extra)
+            throw new IdentityError(404, "Membership not found.");
+        this.scope(actor, tenantId);
+        if (actor.portal !== "super-admin" && portal !== "user")
+            throw new IdentityError(403, "Only super administrators can change privileged memberships.");
+        await this.db.transaction().execute(async (trx) => {
+            checkIdentityRequest();
+            const current = await trx
+                .selectFrom("identity_memberships")
+                .select(["custom_role_id", "version"])
+                .where("user_id", "=", userId)
+                .where("tenant_id", "=", tenantId)
+                .where("role_id", "=", portal)
+                .executeTakeFirst();
+            if (!current ||
+                (current.custom_role_id &&
+                    !(await this.customRoleInApp(trx, current.custom_role_id, actor.appId))))
+                throw new IdentityError(404, "Membership not found.");
+            if (Number(current.version) !== expectedVersion)
+                throw new IdentityError(409, "This record changed. Reload before saving.");
+            await protectAdministrators(trx, userId, this.activeUsers, tenantId, portal);
+            await trx
+                .deleteFrom("identity_memberships")
+                .where("user_id", "=", userId)
+                .where("tenant_id", "=", tenantId)
+                .where("role_id", "=", portal)
+                .execute();
+            await this.revokeMembershipSessions(trx, actor.appId, userId, tenantId, portal);
+            await this.audit(trx, actor, tenantId, "identity.membership.removed", id);
+            checkIdentityRequest();
+        });
+    }
+    manage(actor) {
+        if (actor.portal === "user" || !actor.permissions.includes("identity.manage"))
+            throw new IdentityError(403, "Access denied.");
+    }
+    scope(actor, tenantId) {
+        if (actor.portal !== "super-admin" && tenantId !== actor.tenant.id)
+            throw new IdentityError(403, "Access denied.");
+    }
+    tenantId(actor, requested) {
+        if (requested && requested !== actor.tenant.id && actor.portal !== "super-admin")
+            throw new IdentityError(403, "Access denied.");
+        return requested ?? actor.tenant.id;
+    }
+    async activeTenant(trx, tenantId) {
+        if (!(await this.activeOrganization(trx, tenantId)))
+            throw new IdentityError(422, "Organization is inactive or unavailable.");
+    }
+    async audit(trx, actor, tenantId, action, resourceId) {
+        await this.recordAudit(trx, actor, tenantId, action, resourceId);
+    }
+}

package/dist/modules/identity/user-role/user-role.types.d.ts

@@ -0,0 +1,12 @@
+import type { Generated } from "kysely";
+export interface IdentityUserRoleTables {
+    identity_memberships: {
+        user_id: string;
+        tenant_id: string;
+        role_id: string;
+        custom_role_id: Generated<string | null>;
+        active: Generated<number>;
+        version: Generated<number>;
+    };
+}
+export type IdentityMembershipRow = IdentityUserRoleTables["identity_memberships"];

package/dist/modules/identity/user-role/user-role.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/tenant/index.d.ts

@@ -0,0 +1,6 @@
+export { createTenantProvider } from "./tenant.provider.js";
+export { tenantConnectionsMigration, createLegacyTenantConnectionsMigration, createTenantConnectionsMigration } from "./tenant.migration.js";
+export type { TenantRegistrySchema, TenantMasterSchema, TenantDatabase, TenantScope, TenantPrincipal, TenantIdentity, TenantProvider } from "./tenant.types.js";
+export { verifyTenantReadiness } from "./tenant.readiness.js";
+export { provisionTenant } from "./tenant.seed.js";
+export { executeTenantCommand } from "./tenant.command.js";

package/dist/modules/tenant/index.js

@@ -0,0 +1,5 @@
+export { createTenantProvider } from "./tenant.provider.js";
+export { tenantConnectionsMigration, createLegacyTenantConnectionsMigration, createTenantConnectionsMigration } from "./tenant.migration.js";
+export { verifyTenantReadiness } from "./tenant.readiness.js";
+export { provisionTenant } from "./tenant.seed.js";
+export { executeTenantCommand } from "./tenant.command.js";

package/dist/modules/tenant/tenant.command.d.ts

@@ -0,0 +1,3 @@
+export declare function executeTenantCommand(database: import("./tenant.types.js").TenantDatabase & {
+    provisionConnection(target: import("@devxcrew/framework").ConnectionTarget): Promise<unknown>;
+}, environment: NodeJS.ProcessEnv, command?: string, args?: string[]): Promise<void>;

package/dist/modules/tenant/tenant.command.js

@@ -0,0 +1,43 @@
+import { backupConnection, checkConnectionBackup } from "@devxcrew/framework";
+import { provisionTenant } from "./tenant.seed.js";
+import { tenantMappingSchema } from "./tenant.schema.js";
+import { TenantRepository } from "./tenant.repository.js";
+import { join } from "node:path";
+export async function executeTenantCommand(database, environment, command = "provision", args = []) {
+    if (command === "provision")
+        console.info(await provisionTenant(database, environment));
+    else if (["backup", "verify-backup", "verify-restore"].includes(command)) {
+        const id = environment.IDENTITY_TENANT_ID ?? "default";
+        const row = await new TenantRepository(database.database).find(id);
+        if (!row)
+            throw new Error("Tenant mapping is missing.");
+        const mapping = tenantMappingSchema.parse({
+            tenantId: id,
+            driver: row.driver,
+            databaseName: row.databaseName,
+            sqlitePath: row.sqlitePath,
+            active: Number(row.active),
+            version: Number(row.version)
+        });
+        const target = {
+            key: id,
+            driver: mapping.driver,
+            databaseName: mapping.databaseName,
+            sqlitePath: mapping.sqlitePath,
+            version: mapping.version
+        };
+        const path = args[0] ??
+            (command === "backup"
+                ? join(environment.DB_BACKUP_DIR ?? "storage/private/data/backup", `tenant-${new Date().toISOString().replace(/[:.]/g, "-")}.${mapping.driver === "mariadb" ? "sql" : "sqlite"}`)
+                : undefined);
+        if (!path)
+            throw new Error("Supply a backup path.");
+        if (command === "backup")
+            await backupConnection(environment, target, path);
+        else
+            await checkConnectionBackup(environment, target, path, command === "verify-restore");
+        console.info(`Tenant ${command} passed: ${path}`);
+    }
+    else
+        throw new Error("Unknown tenant command.");
+}

package/dist/modules/tenant/tenant.controller.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseInfrastructureSchema } from "@devxcrew/framework";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { TenantProvider } from "./tenant.types.js";
+export declare function tenantController<Schema extends DatabaseInfrastructureSchema>(provider: TenantProvider<Schema>, request: IncomingMessage, response: ServerResponse, signal?: AbortSignal): Promise<boolean>;

package/dist/modules/tenant/tenant.controller.js

@@ -0,0 +1,12 @@
+export async function tenantController(provider, request, response, signal) {
+    await provider.runRequest(request, async () => {
+        const scope = provider.current();
+        response.writeHead(200, {
+            "Content-Type": "application/json",
+            "Cache-Control": "no-store",
+            "X-Content-Type-Options": "nosniff"
+        });
+        response.end(JSON.stringify({ data: { tenantId: scope.tenantId, portal: scope.principal.portal } }));
+    }, signal);
+    return true;
+}

package/dist/modules/tenant/tenant.migration.d.ts

@@ -0,0 +1,5 @@
+import type { Migration } from "kysely/migration";
+/** Compatibility names come from the consuming app's migration composition. */
+export declare function createLegacyTenantConnectionsMigration(tableName: string): Migration;
+export declare function createTenantConnectionsMigration(previousTable?: string): Migration;
+export declare const tenantConnectionsMigration: Migration;

package/dist/modules/tenant/tenant.migration.js

@@ -0,0 +1,46 @@
+/** Compatibility names come from the consuming app's migration composition. */
+export function createLegacyTenantConnectionsMigration(tableName) {
+    assertTableName(tableName);
+    return {
+        async up(database) {
+            await database.schema
+                .createTable(tableName)
+                .addColumn("tenant_id", "text", (column) => column.primaryKey().references("identity_tenants.id").onDelete("cascade"))
+                .addColumn("driver", "text", (column) => column.notNull())
+                .addColumn("database_name", "text")
+                .addColumn("sqlite_path", "text")
+                .addColumn("active", "integer", (column) => column.notNull().defaultTo(1))
+                .addColumn("version", "integer", (column) => column.notNull().defaultTo(1))
+                .execute();
+        },
+        async down(database) {
+            await database.schema.dropTable(tableName).ifExists().execute();
+        }
+    };
+}
+export function createTenantConnectionsMigration(previousTable) {
+    if (!previousTable)
+        return createLegacyTenantConnectionsMigration("tenant_connections");
+    assertTableName(previousTable);
+    if (previousTable === "tenant_connections")
+        throw new Error("The previous mapping table must differ.");
+    return {
+        async up(database) {
+            const tables = new Set((await database.introspection.getTables()).map((table) => table.name));
+            if (tables.has(previousTable) && tables.has("tenant_connections"))
+                throw new Error("Tenant mapping tables require reconciliation.");
+            if (tables.has(previousTable))
+                await database.schema.alterTable(previousTable).renameTo("tenant_connections").execute();
+            else if (!tables.has("tenant_connections"))
+                throw new Error("The previous tenant migration is missing.");
+        },
+        async down() {
+            throw new Error("Tenant mapping rename requires an explicit recovery plan.");
+        }
+    };
+}
+export const tenantConnectionsMigration = createTenantConnectionsMigration();
+function assertTableName(name) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/.test(name))
+        throw new Error("Invalid migration table name.");
+}

package/dist/modules/tenant/tenant.provider.d.ts

@@ -0,0 +1,3 @@
+import { type DatabaseInfrastructureSchema } from "@devxcrew/framework";
+import type { TenantDatabase, TenantIdentity, TenantProvider } from "./tenant.types.js";
+export declare function createTenantProvider<Schema extends DatabaseInfrastructureSchema = DatabaseInfrastructureSchema>(database: TenantDatabase<Schema>, identity: TenantIdentity, environment: NodeJS.ProcessEnv): TenantProvider<Schema>;

package/dist/modules/tenant/tenant.provider.js

@@ -0,0 +1,44 @@
+import { HttpError } from "@devxcrew/framework";
+import { z } from "zod";
+import { IdentityError, createIdentityTenantDirectory } from "../identity/index.js";
+import { TenantRepository } from "./tenant.repository.js";
+import { TenantService } from "./tenant.service.js";
+import { tenantRequestSchema } from "./tenant.schema.js";
+import { tenantRoutes } from "./tenant.routes.js";
+export function createTenantProvider(database, identity, environment) {
+    const mode = z
+        .enum(["single-client", "multi-tenant"])
+        .parse(environment.IDENTITY_MODE ?? "single-client");
+    const clientId = z
+        .string()
+        .min(1)
+        .parse(environment.IDENTITY_TENANT_ID ?? "default");
+    const service = new TenantService(new TenantRepository(database.database), createIdentityTenantDirectory(database.database), database, mode, clientId);
+    const provider = {
+        handle: (request, response, signal) => tenantRoutes(provider, request, response, signal),
+        current: () => service.current(),
+        verify: () => service.verify(),
+        withPrincipal: (...args) => service.withPrincipal(...args),
+        async runRequest(request, work, signal) {
+            const input = tenantRequestSchema.safeParse({
+                portal: request.headers["x-identity-portal"] ?? "user",
+                tenantId: request.headers["x-tenant-id"]
+            });
+            if (!input.success || request.headers["x-tenant-db"] !== undefined)
+                throw new HttpError(422, "tenant_context_invalid", "Invalid tenant request context.");
+            const principal = await identity
+                .authenticateRequest(request, input.data.portal, signal)
+                .catch((error) => {
+                if (error instanceof IdentityError) {
+                    const fields = error.fields
+                        ? Object.fromEntries(Object.entries(error.fields).map(([key, values]) => [key, [...values]]))
+                        : undefined;
+                    throw new HttpError(error.status, error.code, error.message, fields);
+                }
+                throw error;
+            });
+            return service.withPrincipal(principal, input.data.tenantId, work, signal);
+        }
+    };
+    return provider;
+}

package/dist/modules/tenant/tenant.readiness.d.ts

@@ -0,0 +1,6 @@
+import type { TenantDatabase } from "./tenant.types.js";
+export declare function verifyTenantReadiness(database: TenantDatabase): Promise<{
+    readonly checked: number;
+    readonly unmapped: number;
+    readonly status: "partial" | "ready";
+}>;

package/dist/modules/tenant/tenant.readiness.js

@@ -0,0 +1,45 @@
+import { createIdentityTenantDirectory } from "../identity/index.js";
+import { TenantRepository } from "./tenant.repository.js";
+import { sql } from "kysely";
+import { tenantMappingSchema } from "./tenant.schema.js";
+export async function verifyTenantReadiness(database) {
+    const directory = createIdentityTenantDirectory(database.database);
+    const repository = new TenantRepository(database.database);
+    let cursor = "";
+    let checked = 0;
+    let unmapped = 0;
+    while (true) {
+        const tenants = await directory.listActive(cursor, 50);
+        if (!tenants.length)
+            break;
+        for (const tenant of tenants) {
+            cursor = tenant.id;
+            const row = await repository.find(tenant.id);
+            if (!row) {
+                unmapped++;
+                continue;
+            }
+            if (Number(row.active) !== 1)
+                continue;
+            const parsed = tenantMappingSchema.safeParse({
+                ...row,
+                active: Number(row.active),
+                version: Number(row.version)
+            });
+            if (!parsed.success)
+                throw new Error("An active tenant mapping is invalid.");
+            const mapping = parsed.data;
+            await database.withConnection({
+                key: mapping.tenantId,
+                driver: mapping.driver,
+                databaseName: mapping.databaseName,
+                sqlitePath: mapping.sqlitePath,
+                version: mapping.version
+            }, async (connection) => {
+                await sql `SELECT 1`.execute(connection);
+            });
+            checked++;
+        }
+    }
+    return { checked, unmapped, status: unmapped ? "partial" : "ready" };
+}

package/dist/modules/tenant/tenant.repository.d.ts

@@ -0,0 +1,15 @@
+import type { Kysely } from "kysely";
+import type { TenantMasterSchema } from "./tenant.types.js";
+export declare class TenantRepository {
+    private readonly database;
+    constructor(database: Kysely<TenantMasterSchema>);
+    find(id: string): Promise<{
+        active: number;
+        databaseName: string | null;
+        driver: "mariadb" | "sqlite";
+        sqlitePath: string | null;
+        tenantId: string;
+        version: number;
+    } | undefined>;
+    verify(): Promise<void>;
+}

package/dist/modules/tenant/tenant.repository.js

@@ -0,0 +1,23 @@
+export class TenantRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async find(id) {
+        return this.database
+            .selectFrom("tenant_connections as connection")
+            .select([
+            "connection.tenant_id as tenantId",
+            "connection.driver",
+            "connection.database_name as databaseName",
+            "connection.sqlite_path as sqlitePath",
+            "connection.active",
+            "connection.version"
+        ])
+            .where("connection.tenant_id", "=", id)
+            .executeTakeFirst();
+    }
+    async verify() {
+        await this.database.selectFrom("tenant_connections").select("tenant_id").limit(1).execute();
+    }
+}

package/dist/modules/tenant/tenant.routes.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseInfrastructureSchema } from "@devxcrew/framework";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { TenantProvider } from "./tenant.types.js";
+export declare function tenantRoutes<Schema extends DatabaseInfrastructureSchema>(provider: TenantProvider<Schema>, request: IncomingMessage, response: ServerResponse, signal?: AbortSignal): false | Promise<boolean>;

package/dist/modules/tenant/tenant.routes.js

@@ -0,0 +1,7 @@
+import { tenantController } from "./tenant.controller.js";
+export function tenantRoutes(provider, request, response, signal) {
+    if (new URL(request.url ?? "/", "http://localhost").pathname !== "/api/v1/tenants/current" ||
+        request.method !== "GET")
+        return false;
+    return tenantController(provider, request, response, signal);
+}

package/dist/modules/tenant/tenant.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const tenantRequestSchema: z.ZodObject<{
+    portal: z.ZodDefault<z.ZodEnum<{
+        admin: "admin";
+        "super-admin": "super-admin";
+        user: "user";
+    }>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const tenantMappingSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    driver: z.ZodEnum<{
+        mariadb: "mariadb";
+        sqlite: "sqlite";
+    }>;
+    databaseName: z.ZodNullable<z.ZodString>;
+    sqlitePath: z.ZodNullable<z.ZodString>;
+    active: z.ZodNumber;
+    version: z.ZodNumber;
+}, z.core.$strict>;