@devxcrew/platform 0.1.2 → 0.1.6

package/dist/modules/identity/organization/organization.seed.js

@@ -0,0 +1,11 @@
+export async function seedOrganization(trx, env) {
+    await trx
+        .insertInto("identity_tenants")
+        .values({
+        id: env.IDENTITY_TENANT_ID ?? "default",
+        name: env.IDENTITY_TENANT_NAME ?? "Default organization",
+        active: 1
+    })
+        .onConflict((c) => c.column("id").doNothing())
+        .execute();
+}

package/dist/modules/identity/organization/organization.service.d.ts

@@ -0,0 +1,39 @@
+import type { Transaction } from "kysely";
+import type { IdentityMutation, IdentitySchema, Principal } from "../identity.types.js";
+import { IdentityOrganizationRepository } from "./organization.repository.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+export declare class IdentityOrganizationService {
+    private readonly repository;
+    private readonly mutate;
+    private readonly revokeTenantSessions;
+    constructor(repository: IdentityOrganizationRepository, mutate: IdentityMutation, revokeTenantSessions: (trx: Transaction<IdentitySchema>, tenantId: string) => 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>;
+    create(actor: Principal, raw: unknown): Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        version: number;
+    }>;
+    update(actor: Principal, id: string, raw: unknown): Promise<{
+        active: boolean;
+        version: number;
+        id: string;
+        name: string;
+    }>;
+    private manage;
+}

package/dist/modules/identity/organization/organization.service.js

@@ -0,0 +1,55 @@
+import { IdentityError } from "../support/identity.error.js";
+import { organizationCreateSchema, organizationUpdateSchema } from "./organization.schema.js";
+export class IdentityOrganizationService {
+    repository;
+    mutate;
+    revokeTenantSessions;
+    constructor(repository, mutate, revokeTenantSessions) {
+        this.repository = repository;
+        this.mutate = mutate;
+        this.revokeTenantSessions = revokeTenantSessions;
+    }
+    list(actor, query) {
+        if (actor.portal === "user")
+            throw new IdentityError(403, "Access denied.");
+        return this.repository.list(actor, query);
+    }
+    show(actor, id) {
+        if (actor.portal === "user")
+            throw new IdentityError(403, "Access denied.");
+        return this.repository.show(actor, id);
+    }
+    async create(actor, raw) {
+        this.manage(actor);
+        const input = organizationCreateSchema.parse(raw);
+        return this.mutate(actor, "organizations", input.id, async (trx) => {
+            if (await this.repository.exists(trx, input.id))
+                throw new IdentityError(409, "Organization already exists.");
+            await this.repository.create(trx, input);
+            return { ...input, version: 0 };
+        });
+    }
+    async update(actor, id, raw) {
+        this.manage(actor);
+        if (!(await this.show(actor, id)))
+            throw new IdentityError(404, "Resource not found.");
+        const input = organizationUpdateSchema.parse(raw);
+        return this.mutate(actor, "organizations", id, async (trx) => {
+            const current = await this.repository.version(trx, id);
+            if (Number(current.version) !== input.expectedVersion)
+                throw new IdentityError(409, "This record changed. Reload before saving.");
+            if (input.active === false && id === actor.tenant.id)
+                throw new IdentityError(409, "Cannot deactivate your current organization.");
+            if (!(await this.repository.update(trx, id, input)))
+                throw new IdentityError(409, "This record changed. Reload before saving.");
+            if (input.active === false)
+                await this.revokeTenantSessions(trx, id);
+            const row = await this.repository.get(trx, id);
+            return { ...row, active: Boolean(row.active), version: Number(row.version) };
+        });
+    }
+    manage(actor) {
+        if (actor.portal !== "super-admin" || !actor.permissions.includes("identity.manage"))
+            throw new IdentityError(403, "Only super administrators can change this resource.");
+    }
+}

package/dist/modules/identity/organization/organization.types.d.ts

@@ -0,0 +1,19 @@
+import type { Generated } from "kysely";
+export interface IdentityOrganizationTables {
+    identity_tenants: {
+        id: string;
+        name: string;
+        active: number;
+        version: Generated<number>;
+    };
+}
+export type IdentityOrganizationRow = IdentityOrganizationTables["identity_tenants"];
+export interface IdentityTenantDirectory {
+    active(id: string): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+    listActive(after: string, pageSize: number): Promise<{
+        id: string;
+    }[]>;
+}

package/dist/modules/identity/organization/organization.types.js

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

package/dist/modules/identity/permission/index.d.ts

@@ -0,0 +1,9 @@
+export { createIdentityPermissionProvider } from "./permission.provider.js";
+export type { IdentityPermissionProvider } from "./permission.provider.js";
+export type { IdentityPermissionDeclaration } from "./permission.schema.js";
+export { defaultPermissions, seedPermissions } from "./permission.seed.js";
+export { permissionResource, permissionResourceRoute } from "./permission.routes.js";
+export { identityPermissionDeclarationsMigration } from "./permission.declarations.migration.js";
+export { identityPermissionLabelsMigration } from "./permission.labels.migration.js";
+export type { IdentityPermissionRow, IdentityPermissionDeclarationRow } from "./permission.types.js";
+export { IdentityPermissionController } from "./permission.controller.js";

package/dist/modules/identity/permission/index.js

@@ -0,0 +1,6 @@
+export { createIdentityPermissionProvider } from "./permission.provider.js";
+export { defaultPermissions, seedPermissions } from "./permission.seed.js";
+export { permissionResource, permissionResourceRoute } from "./permission.routes.js";
+export { identityPermissionDeclarationsMigration } from "./permission.declarations.migration.js";
+export { identityPermissionLabelsMigration } from "./permission.labels.migration.js";
+export { IdentityPermissionController } from "./permission.controller.js";

package/dist/modules/identity/permission/permission.controller.d.ts

@@ -0,0 +1,21 @@
+import type { Principal } from "../identity.types.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+import type { IdentityPermissionProvider } from "./permission.provider.js";
+export declare class IdentityPermissionController {
+    private readonly service;
+    constructor(service: IdentityPermissionProvider);
+    index(actor: Principal, query: IdentityListQuery): Promise<{
+        data: {
+            portals: string[];
+        }[];
+        meta: {
+            page: number;
+            perPage: number;
+            total: number;
+            lastPage: number;
+        };
+    }>;
+    show(actor: Principal, id: string): Promise<{
+        portals: string[];
+    } | undefined>;
+}

package/dist/modules/identity/permission/permission.controller.js

@@ -0,0 +1,12 @@
+export class IdentityPermissionController {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    index(actor, query) {
+        return this.service.list(actor, query);
+    }
+    show(actor, id) {
+        return this.service.show(actor, id);
+    }
+}

package/dist/modules/identity/{identity.permission-declarations-migration.js → permission/permission.declarations.migration.js}

@@ -1,15 +1,20 @@
 export const identityPermissionDeclarationsMigration = {
     async up(db) {
-        await db.schema.createTable("identity_permission_declarations")
+        await db.schema
+            .createTable("identity_permission_declarations")
             .addColumn("permission_id", "text", (column) => column.primaryKey().references("identity_permissions.id"))
             .addColumn("app_id", "text", (column) => column.notNull())
             .addColumn("owner", "text", (column) => column.notNull())
-            .addColumn("portals", "text", (column) => column.notNull()).execute();
+            .addColumn("portals", "text", (column) => column.notNull())
+            .execute();
     },
     async down(db) {
-        const declared = await db.selectFrom("identity_permission_declarations").select("permission_id").executeTakeFirst();
+        const declared = await db
+            .selectFrom("identity_permission_declarations")
+            .select("permission_id")
+            .executeTakeFirst();
         if (declared)
             throw new Error("Restore a compatible snapshot before removing permission ownership restrictions.");
         await db.schema.dropTable("identity_permission_declarations").execute();
-    },
+    }
 };

package/dist/modules/identity/{identity.permission-labels-migration.js → permission/permission.labels.migration.js}

@@ -1,9 +1,12 @@
 // Additive migration. Do not rewrite the previously applied declaration schema.
 export const identityPermissionLabelsMigration = {
     async up(db) {
-        await db.schema.alterTable("identity_permission_declarations").addColumn("label", "text").execute();
+        await db.schema
+            .alterTable("identity_permission_declarations")
+            .addColumn("label", "text")
+            .execute();
     },
     async down(db) {
         await db.schema.alterTable("identity_permission_declarations").dropColumn("label").execute();
-    },
+    }
 };

package/dist/modules/identity/permission/permission.migration.d.ts

@@ -0,0 +1,2 @@
+export { identityPermissionDeclarationsMigration } from "./permission.declarations.migration.js";
+export { identityPermissionLabelsMigration } from "./permission.labels.migration.js";

package/dist/modules/identity/permission/permission.migration.js

@@ -0,0 +1,2 @@
+export { identityPermissionDeclarationsMigration } from "./permission.declarations.migration.js";
+export { identityPermissionLabelsMigration } from "./permission.labels.migration.js";

package/dist/modules/identity/permission/permission.provider.d.ts

@@ -0,0 +1,19 @@
+import type { Kysely, Transaction } from "kysely";
+import type { IdentitySchema, Portal } from "../identity.types.js";
+import type { IdentityPermissionDeclaration } from "./permission.schema.js";
+import { IdentityPermissionService } from "./permission.service.js";
+import type { Principal } from "../identity.types.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+export interface IdentityPermissionProvider {
+    verify(): Promise<void>;
+    list(actor: Principal, query: IdentityListQuery): ReturnType<IdentityPermissionService["list"]>;
+    show(actor: Principal, id: string): ReturnType<IdentityPermissionService["show"]>;
+    register(appId: string, declaration: IdentityPermissionDeclaration): Promise<{
+        owner: string;
+        permissionIds: string[];
+    }>;
+    validateDeclared(database: Kysely<IdentitySchema> | Transaction<IdentitySchema>, appId: string, portal: Portal, ids: string[]): Promise<void>;
+    validateKnown(database: Transaction<IdentitySchema>, ids: string[]): Promise<void>;
+    filterDeclared(database: Kysely<IdentitySchema>, appId: string, portal: Portal, ids: string[]): Promise<string[]>;
+}
+export declare function createIdentityPermissionProvider(database: Kysely<IdentitySchema>): IdentityPermissionProvider;

package/dist/modules/identity/permission/permission.provider.js

@@ -0,0 +1,14 @@
+import { IdentityPermissionRepository } from "./permission.repository.js";
+import { IdentityPermissionService } from "./permission.service.js";
+export function createIdentityPermissionProvider(database) {
+    const service = new IdentityPermissionService(new IdentityPermissionRepository(database));
+    return Object.freeze({
+        verify: service.verify.bind(service),
+        list: service.list.bind(service),
+        show: service.show.bind(service),
+        register: service.register.bind(service),
+        validateDeclared: service.validateDeclared.bind(service),
+        validateKnown: service.validateKnown.bind(service),
+        filterDeclared: service.filterDeclared.bind(service)
+    });
+}

package/dist/modules/identity/permission/permission.repository.d.ts

@@ -0,0 +1,51 @@
+import { type Kysely, type Transaction } from "kysely";
+import type { IdentitySchema, Principal } from "../identity.types.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+type Database = Kysely<IdentitySchema> | Transaction<IdentitySchema>;
+export declare class IdentityPermissionRepository {
+    private readonly db;
+    constructor(db: Kysely<IdentitySchema>);
+    verifySchema(): Promise<void>;
+    list(actor: Principal, query: IdentityListQuery): Promise<{
+        data: {
+            portals: string[];
+        }[];
+        meta: {
+            page: number;
+            perPage: number;
+            total: number;
+            lastPage: number;
+        };
+    }>;
+    show(actor: Principal, id: string): Promise<{
+        portals: string[];
+    } | undefined>;
+    transaction<T>(action: (trx: Transaction<IdentitySchema>) => Promise<T>): Promise<T>;
+    declaration(db: Database, id: string): Promise<{
+        app_id: string;
+        label: string | null;
+        owner: string;
+        permission_id: string;
+        portals: string;
+    } | undefined>;
+    declarations(db: Database): Promise<{
+        app_id: string;
+        label: string | null;
+        owner: string;
+        permission_id: string;
+        portals: string;
+    }[]>;
+    permission(db: Database, id: string): Promise<{
+        id: string;
+    } | undefined>;
+    knownIds(db: Database): Promise<Set<string>>;
+    updateLabel(trx: Transaction<IdentitySchema>, id: string, label: string): Promise<void>;
+    create(trx: Transaction<IdentitySchema>, input: {
+        id: string;
+        appId: string;
+        owner: string;
+        portals: string;
+        label: string | null;
+    }): Promise<void>;
+}
+export {};

package/dist/modules/identity/permission/permission.repository.js

@@ -0,0 +1,84 @@
+import { sql } from "kysely";
+import { listRows, showRow } from "../support/pagination.js";
+function permissionListSource(actor) {
+    return sql `select p.id,coalesce(d.label,p.id) as label,
+    coalesce(d.owner,case when p.id like 'desk.%' then 'desk' else 'identity' end) as owner,
+    d.app_id as appId,
+    coalesce(d.portals,case when p.id='desk.user' then '["user"]' when p.id='desk.admin' then '["admin"]'
+      when p.id='desk.super-admin' then '["super-admin"]' when p.id='identity.manage' then '["admin","super-admin"]'
+      else '["user","admin","super-admin"]' end) as portals
+    from identity_permissions p left join identity_permission_declarations d on d.permission_id=p.id
+    where d.permission_id is null or d.app_id=${actor.appId}`;
+}
+export class IdentityPermissionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async verifySchema() {
+        await this.db.selectFrom("identity_permissions").select("id").limit(1).execute();
+        await this.db
+            .selectFrom("identity_permission_declarations")
+            .select(["permission_id", "label"])
+            .limit(1)
+            .execute();
+    }
+    list(actor, query) {
+        const present = (row) => ({
+            ...row,
+            portals: JSON.parse(String(row.portals))
+        });
+        return listRows(this.db, permissionListSource(actor), ["id"], query, present);
+    }
+    show(actor, id) {
+        const present = (row) => ({
+            ...row,
+            portals: JSON.parse(String(row.portals))
+        });
+        return showRow(this.db, permissionListSource(actor), id, present);
+    }
+    transaction(action) {
+        return this.db.transaction().execute(action);
+    }
+    declaration(db, id) {
+        return db
+            .selectFrom("identity_permission_declarations")
+            .selectAll()
+            .where("permission_id", "=", id)
+            .executeTakeFirst();
+    }
+    declarations(db) {
+        return db.selectFrom("identity_permission_declarations").selectAll().execute();
+    }
+    permission(db, id) {
+        return db
+            .selectFrom("identity_permissions")
+            .select("id")
+            .where("id", "=", id)
+            .executeTakeFirst();
+    }
+    async knownIds(db) {
+        const rows = await db.selectFrom("identity_permissions").select("id").execute();
+        return new Set(rows.map((row) => row.id));
+    }
+    async updateLabel(trx, id, label) {
+        await trx
+            .updateTable("identity_permission_declarations")
+            .set({ label })
+            .where("permission_id", "=", id)
+            .execute();
+    }
+    async create(trx, input) {
+        await trx.insertInto("identity_permissions").values({ id: input.id }).execute();
+        await trx
+            .insertInto("identity_permission_declarations")
+            .values({
+            permission_id: input.id,
+            app_id: input.appId,
+            owner: input.owner,
+            portals: input.portals,
+            label: input.label
+        })
+            .execute();
+    }
+}

package/dist/modules/identity/permission/permission.routes.d.ts

@@ -0,0 +1,5 @@
+export declare const permissionResource: "permissions";
+export declare const permissionResourceRoute: (controller: import("./permission.controller.js").IdentityPermissionController) => {
+    resource: "permissions";
+    controller: import("./permission.controller.js").IdentityPermissionController;
+};

package/dist/modules/identity/permission/permission.routes.js

@@ -0,0 +1,2 @@
+export const permissionResource = "permissions";
+export const permissionResourceRoute = (controller) => ({ resource: permissionResource, controller });

package/dist/modules/identity/permission/permission.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const permissionDeclarationSchema: z.ZodObject<{
+    owner: z.ZodString;
+    permissions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        portals: z.ZodArray<z.ZodEnum<{
+            admin: "admin";
+            "super-admin": "super-admin";
+            user: "user";
+        }>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type IdentityPermissionDeclaration = z.input<typeof permissionDeclarationSchema>;

package/dist/modules/identity/permission/permission.schema.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { portalSchema } from "../support/identity.schema.js";
+export const permissionDeclarationSchema = z
+    .object({
+    owner: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]{0,63}$/)
+        .refine((value) => !["identity", "desk"].includes(value)),
+    permissions: z
+        .array(z
+        .object({
+        id: z
+            .string()
+            .regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*){2,8}$/)
+            .max(250),
+        portals: z.array(portalSchema).min(1).max(3),
+        label: z
+            .string()
+            .trim()
+            .min(1)
+            .max(100)
+            .regex(/^[^\x00-\x1f\x7f]+$/)
+            .optional()
+    })
+        .strict())
+        .min(1)
+        .max(100)
+})
+    .strict();

package/dist/modules/identity/permission/permission.seed.d.ts

@@ -0,0 +1,4 @@
+import type { Transaction } from "kysely";
+import type { IdentitySchema, Portal } from "../identity.types.js";
+export declare function defaultPermissions(portal: Portal): string[];
+export declare function seedPermissions(trx: Transaction<IdentitySchema>): Promise<void>;

package/dist/modules/identity/permission/permission.seed.js

@@ -0,0 +1,17 @@
+export function defaultPermissions(portal) {
+    return [
+        `desk.${portal}`,
+        "identity.self",
+        "identity.password",
+        ...(portal === "user" ? [] : ["identity.manage"])
+    ];
+}
+export async function seedPermissions(trx) {
+    for (const portal of ["user", "admin", "super-admin"])
+        for (const permission of defaultPermissions(portal))
+            await trx
+                .insertInto("identity_permissions")
+                .values({ id: permission })
+                .onConflict((c) => c.column("id").doNothing())
+                .execute();
+}

package/dist/modules/identity/permission/permission.service.d.ts

@@ -0,0 +1,31 @@
+import type { Kysely, Transaction } from "kysely";
+import type { IdentitySchema, Portal } from "../identity.types.js";
+import { IdentityPermissionRepository } from "./permission.repository.js";
+import type { Principal } from "../identity.types.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+export declare class IdentityPermissionService {
+    private readonly repository;
+    constructor(repository: IdentityPermissionRepository);
+    verify(): Promise<void>;
+    list(actor: Principal, query: IdentityListQuery): Promise<{
+        data: {
+            portals: string[];
+        }[];
+        meta: {
+            page: number;
+            perPage: number;
+            total: number;
+            lastPage: number;
+        };
+    }>;
+    show(actor: Principal, id: string): Promise<{
+        portals: string[];
+    } | undefined>;
+    register(appId: string, raw: unknown): Promise<{
+        owner: string;
+        permissionIds: string[];
+    }>;
+    validateDeclared(db: Kysely<IdentitySchema> | Transaction<IdentitySchema>, appId: string, portal: Portal, ids: string[]): Promise<void>;
+    validateKnown(db: Transaction<IdentitySchema>, ids: string[]): Promise<void>;
+    filterDeclared(db: Kysely<IdentitySchema>, appId: string, portal: Portal, ids: string[]): Promise<string[]>;
+}

package/dist/modules/identity/permission/permission.service.js

@@ -0,0 +1,77 @@
+import { IdentityError } from "../support/identity.error.js";
+import { permissionDeclarationSchema } from "./permission.schema.js";
+export class IdentityPermissionService {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    verify() {
+        return this.repository.verifySchema();
+    }
+    list(actor, query) {
+        if (actor.portal === "user")
+            throw new IdentityError(403, "Access denied.");
+        return this.repository.list(actor, query);
+    }
+    show(actor, id) {
+        if (actor.portal === "user")
+            throw new IdentityError(403, "Access denied.");
+        return this.repository.show(actor, id);
+    }
+    async register(appId, raw) {
+        const declaration = permissionDeclarationSchema.parse(raw);
+        const ids = new Set();
+        for (const permission of declaration.permissions) {
+            if (!permission.id.startsWith(`${appId}.${declaration.owner}.`) || ids.has(permission.id))
+                throw new IdentityError(422, "Use unique permission IDs in this app and owner namespace.");
+            ids.add(permission.id);
+        }
+        return this.repository.transaction(async (trx) => {
+            for (const permission of declaration.permissions) {
+                const portals = JSON.stringify([...new Set(permission.portals)].sort());
+                const previous = await this.repository.declaration(trx, permission.id);
+                if (previous) {
+                    if (previous.app_id !== appId ||
+                        previous.owner !== declaration.owner ||
+                        previous.portals !== portals)
+                        throw new IdentityError(409, "Permission declaration conflicts with its registered owner or portal policy.");
+                    if (permission.label !== undefined && permission.label !== previous.label)
+                        await this.repository.updateLabel(trx, permission.id, permission.label);
+                    continue;
+                }
+                if (await this.repository.permission(trx, permission.id))
+                    throw new IdentityError(409, "Permission already exists without this owner declaration.");
+                await this.repository.create(trx, {
+                    id: permission.id,
+                    appId,
+                    owner: declaration.owner,
+                    portals,
+                    label: permission.label ?? null
+                });
+            }
+            return { owner: declaration.owner, permissionIds: [...ids] };
+        });
+    }
+    async validateDeclared(db, appId, portal, ids) {
+        const declarations = await this.repository.declarations(db);
+        for (const id of ids) {
+            const declaration = declarations.find((row) => row.permission_id === id);
+            if (declaration &&
+                (declaration.app_id !== appId || !JSON.parse(declaration.portals).includes(portal)))
+                throw new IdentityError(403, "Permission is unavailable in this app or portal.");
+        }
+    }
+    async validateKnown(db, ids) {
+        const known = await this.repository.knownIds(db);
+        if (ids.some((id) => !known.has(id)))
+            throw new IdentityError(422, "Unknown permission.");
+    }
+    async filterDeclared(db, appId, portal, ids) {
+        const declarations = await this.repository.declarations(db);
+        return ids.filter((id) => {
+            const declaration = declarations.find((row) => row.permission_id === id);
+            return (!declaration ||
+                (declaration.app_id === appId && JSON.parse(declaration.portals).includes(portal)));
+        });
+    }
+}

package/dist/modules/identity/permission/permission.types.d.ts

@@ -0,0 +1,15 @@
+import type { Generated } from "kysely";
+export interface IdentityPermissionTables {
+    identity_permissions: {
+        id: string;
+    };
+    identity_permission_declarations: {
+        permission_id: string;
+        app_id: string;
+        owner: string;
+        portals: string;
+        label: Generated<string | null>;
+    };
+}
+export type IdentityPermissionRow = IdentityPermissionTables["identity_permissions"];
+export type IdentityPermissionDeclarationRow = IdentityPermissionTables["identity_permission_declarations"];

package/dist/modules/identity/permission/permission.types.js

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

package/dist/modules/identity/role/index.d.ts

@@ -0,0 +1,10 @@
+import type { IdentityRoleProvider } from "./role.provider.js";
+export { createIdentityRoleProvider } from "./role.provider.js";
+export { identityRolesMigration } from "./role.migration.js";
+export { seedRoles } from "./role.seed.js";
+export { roleResource, roleResourceRoute } from "./role.routes.js";
+export { customRoleCreateSchema, customRoleUpdateSchema, roleUpdateSchema } from "./role.schema.js";
+export type { IdentityRoleProvider };
+export type IdentityRoleResolver = IdentityRoleProvider["resolve"];
+export type { IdentityRoleRow, IdentityCustomRoleRow } from "./role.types.js";
+export { IdentityRoleController } from "./role.controller.js";

package/dist/modules/identity/role/index.js

@@ -0,0 +1,6 @@
+export { createIdentityRoleProvider } from "./role.provider.js";
+export { identityRolesMigration } from "./role.migration.js";
+export { seedRoles } from "./role.seed.js";
+export { roleResource, roleResourceRoute } from "./role.routes.js";
+export { customRoleCreateSchema, customRoleUpdateSchema, roleUpdateSchema } from "./role.schema.js";
+export { IdentityRoleController } from "./role.controller.js";