@devxcrew/platform 0.1.2 → 0.1.6

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

@@ -1,5 +1,14 @@
-import type { Generated } from "kysely";
-import type { IdentityPermissionDeclaration } from "./identity.permission-declarations.js";
+import type { Transaction } from "kysely";
+import type { IdentityPermissionDeclaration } from "./permission/index.js";
+import type { IdentityUserTables } from "./user/user.types.js";
+import type { IdentityOrganizationTables } from "./organization/organization.types.js";
+import type { IdentityRoleTables } from "./role/role.types.js";
+import type { IdentityPermissionTables } from "./permission/permission.types.js";
+import type { IdentityRolePermissionTables } from "./role-permission/role-permission.types.js";
+import type { IdentityUserRoleTables } from "./user-role/user-role.types.js";
+import type { IdentitySessionTables } from "./session/session.types.js";
+import type { IdentitySettingsTables } from "./settings/settings.types.js";
+import type { IdentityAuditTables } from "./audit/audit.types.js";
 export type Portal = "user" | "admin" | "super-admin";
 export interface IdentityPermissionCatalogEntry {
     id: string;
@@ -29,110 +38,8 @@ export interface Principal {
     };
     permissions: string[];
 }
-export interface IdentitySchema {
-    identity_permission_declarations: {
-        permission_id: string;
-        app_id: string;
-        owner: string;
-        portals: string;
-        label: Generated<string | null>;
-    };
-    identity_app_settings: {
-        app_id: string;
-        display_name: string;
-        locale: string;
-        time_zone: string;
-        session_seconds: number;
-        version: Generated<number>;
-    };
-    identity_tokens: {
-        id: string;
-        token_hash: string;
-        app_id: string;
-        tenant_id: string;
-        kind: "invitation" | "recovery";
-        email: string;
-        name: string;
-        role_id: Portal;
-        user_id: string | null;
-        expires_at: string;
-        consumed_at: string | null;
-        delivered: number;
-    };
-    identity_users: {
-        id: string;
-        email: string;
-        name: string;
-        password_hash: string;
-        active: number;
-        version: Generated<number>;
-    };
-    identity_tenants: {
-        id: string;
-        name: string;
-        active: number;
-        version: Generated<number>;
-    };
-    identity_roles: {
-        id: string;
-        version: Generated<number>;
-    };
-    identity_permissions: {
-        id: string;
-    };
-    identity_role_permissions: {
-        role_id: string;
-        permission_id: string;
-    };
-    identity_memberships: {
-        user_id: string;
-        tenant_id: string;
-        role_id: string;
-        custom_role_id: Generated<string | null>;
-        active: Generated<number>;
-        version: Generated<number>;
-    };
-    identity_custom_roles: {
-        id: string;
-        app_id: string;
-        tenant_id: string;
-        name: string;
-        active: Generated<number>;
-        version: Generated<number>;
-    };
-    identity_custom_role_permissions: {
-        role_id: string;
-        permission_id: string;
-    };
-    identity_sessions: {
-        token_hash: string;
-        user_id: string;
-        tenant_id: string;
-        app_id: string;
-        portal: Portal;
-        expires_at: string;
-    };
-    identity_throttles: {
-        key: string;
-        attempts: number;
-        expires_at: string;
-    };
-    identity_settings: {
-        tenant_id: string;
-        display_name: string;
-        locale: string;
-        time_zone: string;
-        version: Generated<number>;
-    };
-    identity_audit_events: {
-        id: string;
-        app_id: string;
-        actor_id: string;
-        tenant_id: string;
-        action: string;
-        resource_id: string;
-        created_at: string;
-    };
+export type IdentityMutation = <T>(actor: Principal, resource: string, id: string, action: (trx: Transaction<IdentitySchema>, id: string) => Promise<T>, affectedTenant?: string) => Promise<T>;
+export interface IdentitySchema extends IdentityUserTables, IdentityOrganizationTables, IdentityRoleTables, IdentityPermissionTables, IdentityRolePermissionTables, IdentityUserRoleTables, IdentitySessionTables, IdentitySettingsTables, IdentityAuditTables {
 }
 export interface IdentityDeliveryProvider {
     send(input: {

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

@@ -1,12 +1,19 @@
 export { createIdentityProvider } from "./identity.provider.js";
-export { IdentityError } from "./identity.error.js";
-export { identityMigration } from "./identity.migration.js";
-export { identityAdministrationMigration } from "./identity.administration-migration.js";
-export { identityRolesMigration } from "./identity.roles-migration.js";
-export { identityPermissionDeclarationsMigration } from "./identity.permission-declarations-migration.js";
-export { identityPermissionLabelsMigration } from "./identity.permission-labels-migration.js";
-export type { IdentityPermissionDeclaration } from "./identity.permission-declarations.js";
-export { listSchema, userCreateSchema, userUpdateSchema, organizationCreateSchema, organizationUpdateSchema, membershipSchema, roleUpdateSchema, profileSchema, settingsSchema, } from "./identity.administration-schema.js";
-export type { IdentityListQuery, IdentityResource, } from "./identity.administration-schema.js";
-export { seedIdentity } from "./identity.seed.js";
-export type { IdentitySchema, IdentityConfig, Principal, Portal, IdentityDeliveryProvider, IdentityProviderOptions, IdentityPermissionCatalogEntry, } from "./identity.types.js";
+export { createIdentityTenantDirectory } from "./organization/index.js";
+export type { IdentityTenantDirectory } from "./organization/index.js";
+export { IdentityError } from "./support/identity.error.js";
+export { identityMigration } from "./legacy/identity.migration.js";
+export { identityAdministrationMigration } from "./legacy/identity.administration-migration.js";
+export { identityRolesMigration } from "./role/index.js";
+export { identityPermissionDeclarationsMigration } from "./permission/index.js";
+export { identityPermissionLabelsMigration } from "./permission/index.js";
+export type { IdentityPermissionDeclaration } from "./permission/index.js";
+export { listSchema } from "./support/pagination.schema.js";
+export { organizationCreateSchema, organizationUpdateSchema } from "./organization/index.js";
+export { settingsSchema } from "./settings/index.js";
+export { userCreateSchema, userUpdateSchema, profileSchema } from "./user/index.js";
+export { membershipSchema, membershipUpdateSchema, membershipDeleteQuerySchema } from "./user-role/index.js";
+export { customRoleCreateSchema, customRoleUpdateSchema, roleUpdateSchema } from "./role/index.js";
+export type { IdentityListQuery, IdentityResource } from "./support/pagination.schema.js";
+export { seedIdentity } from "./composition/identity.seed.js";
+export type { IdentitySchema, IdentityConfig, Principal, Portal, IdentityDeliveryProvider, IdentityProviderOptions, IdentityPermissionCatalogEntry } from "./identity.types.js";

package/dist/modules/identity/index.js

@@ -1,9 +1,15 @@
 export { createIdentityProvider } from "./identity.provider.js";
-export { IdentityError } from "./identity.error.js";
-export { identityMigration } from "./identity.migration.js";
-export { identityAdministrationMigration } from "./identity.administration-migration.js";
-export { identityRolesMigration } from "./identity.roles-migration.js";
-export { identityPermissionDeclarationsMigration } from "./identity.permission-declarations-migration.js";
-export { identityPermissionLabelsMigration } from "./identity.permission-labels-migration.js";
-export { listSchema, userCreateSchema, userUpdateSchema, organizationCreateSchema, organizationUpdateSchema, membershipSchema, roleUpdateSchema, profileSchema, settingsSchema, } from "./identity.administration-schema.js";
-export { seedIdentity } from "./identity.seed.js";
+export { createIdentityTenantDirectory } from "./organization/index.js";
+export { IdentityError } from "./support/identity.error.js";
+export { identityMigration } from "./legacy/identity.migration.js";
+export { identityAdministrationMigration } from "./legacy/identity.administration-migration.js";
+export { identityRolesMigration } from "./role/index.js";
+export { identityPermissionDeclarationsMigration } from "./permission/index.js";
+export { identityPermissionLabelsMigration } from "./permission/index.js";
+export { listSchema } from "./support/pagination.schema.js";
+export { organizationCreateSchema, organizationUpdateSchema } from "./organization/index.js";
+export { settingsSchema } from "./settings/index.js";
+export { userCreateSchema, userUpdateSchema, profileSchema } from "./user/index.js";
+export { membershipSchema, membershipUpdateSchema, membershipDeleteQuerySchema } from "./user-role/index.js";
+export { customRoleCreateSchema, customRoleUpdateSchema, roleUpdateSchema } from "./role/index.js";
+export { seedIdentity } from "./composition/identity.seed.js";

package/dist/modules/identity/{identity.administration-migration.js → legacy/identity.administration-migration.js}

@@ -1,10 +1,6 @@
 export const identityAdministrationMigration = {
     async up(db) {
-        for (const table of [
-            "identity_users",
-            "identity_tenants",
-            "identity_roles",
-        ])
+        for (const table of ["identity_users", "identity_tenants", "identity_roles"])
             await db.schema
                 .alterTable(table)
                 .addColumn("version", "integer", (c) => c.notNull().defaultTo(0))
@@ -61,15 +57,11 @@ export const identityAdministrationMigration = {
             .execute();
     },
     async down(db) {
-        for (const table of [
-            "identity_users",
-            "identity_tenants",
-            "identity_roles",
-        ])
+        for (const table of ["identity_users", "identity_tenants", "identity_roles"])
             await db.schema.alterTable(table).dropColumn("version").execute();
         await db.schema.dropTable("identity_app_settings").execute();
         await db.schema.dropTable("identity_tokens").execute();
         await db.schema.dropTable("identity_audit_events").execute();
         await db.schema.dropTable("identity_settings").execute();
-    },
+    }
 };

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

@@ -0,0 +1,2 @@
+import type { Migration } from "kysely/migration";
+export declare const identityMigration: Migration;

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

@@ -0,0 +1,72 @@
+export const identityMigration = {
+    async up(db) {
+        await db.schema
+            .createTable("identity_users")
+            .addColumn("id", "text", (c) => c.primaryKey())
+            .addColumn("email", "text", (c) => c.notNull().unique())
+            .addColumn("name", "text", (c) => c.notNull())
+            .addColumn("password_hash", "text", (c) => c.notNull())
+            .addColumn("active", "integer", (c) => c.notNull().defaultTo(1))
+            .execute();
+        await db.schema
+            .createTable("identity_tenants")
+            .addColumn("id", "text", (c) => c.primaryKey())
+            .addColumn("name", "text", (c) => c.notNull())
+            .addColumn("active", "integer", (c) => c.notNull().defaultTo(1))
+            .execute();
+        await db.schema
+            .createTable("identity_roles")
+            .addColumn("id", "text", (c) => c.primaryKey())
+            .execute();
+        await db.schema
+            .createTable("identity_permissions")
+            .addColumn("id", "text", (c) => c.primaryKey())
+            .execute();
+        await db.schema
+            .createTable("identity_role_permissions")
+            .addColumn("role_id", "text", (c) => c.notNull().references("identity_roles.id"))
+            .addColumn("permission_id", "text", (c) => c.notNull().references("identity_permissions.id"))
+            .addPrimaryKeyConstraint("identity_role_permission_pk", ["role_id", "permission_id"])
+            .execute();
+        await db.schema
+            .createTable("identity_memberships")
+            .addColumn("user_id", "text", (c) => c.notNull().references("identity_users.id").onDelete("cascade"))
+            .addColumn("tenant_id", "text", (c) => c.notNull().references("identity_tenants.id").onDelete("cascade"))
+            .addColumn("role_id", "text", (c) => c.notNull().references("identity_roles.id"))
+            .addPrimaryKeyConstraint("identity_membership_pk", ["user_id", "tenant_id", "role_id"])
+            .execute();
+        await db.schema
+            .createTable("identity_sessions")
+            .addColumn("token_hash", "text", (c) => c.primaryKey())
+            .addColumn("user_id", "text", (c) => c.notNull().references("identity_users.id").onDelete("cascade"))
+            .addColumn("tenant_id", "text", (c) => c.notNull().references("identity_tenants.id").onDelete("cascade"))
+            .addColumn("app_id", "text", (c) => c.notNull())
+            .addColumn("portal", "text", (c) => c.notNull())
+            .addColumn("expires_at", "text", (c) => c.notNull())
+            .execute();
+        await db.schema
+            .createIndex("identity_sessions_expiry")
+            .on("identity_sessions")
+            .column("expires_at")
+            .execute();
+        await db.schema
+            .createTable("identity_throttles")
+            .addColumn("key", "text", (c) => c.primaryKey())
+            .addColumn("attempts", "integer", (c) => c.notNull())
+            .addColumn("expires_at", "text", (c) => c.notNull())
+            .execute();
+    },
+    async down(db) {
+        for (const table of [
+            "identity_throttles",
+            "identity_sessions",
+            "identity_memberships",
+            "identity_role_permissions",
+            "identity_permissions",
+            "identity_roles",
+            "identity_tenants",
+            "identity_users"
+        ])
+            await db.schema.dropTable(table).execute();
+    }
+};

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

@@ -0,0 +1,6 @@
+export { createIdentityOrganizationProvider, createIdentityTenantDirectory } from "./organization.provider.js";
+export { organizationCreateSchema, organizationUpdateSchema } from "./organization.schema.js";
+export { seedOrganization } from "./organization.seed.js";
+export { organizationResource, organizationResourceRoute } from "./organization.routes.js";
+export type { IdentityOrganizationRow, IdentityTenantDirectory } from "./organization.types.js";
+export { IdentityOrganizationController } from "./organization.controller.js";

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

@@ -0,0 +1,5 @@
+export { createIdentityOrganizationProvider, createIdentityTenantDirectory } from "./organization.provider.js";
+export { organizationCreateSchema, organizationUpdateSchema } from "./organization.schema.js";
+export { seedOrganization } from "./organization.seed.js";
+export { organizationResource, organizationResourceRoute } from "./organization.routes.js";
+export { IdentityOrganizationController } from "./organization.controller.js";

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

@@ -0,0 +1,35 @@
+import type { Principal } from "../identity.types.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+import type { createIdentityOrganizationProvider } from "./organization.provider.js";
+export declare class IdentityOrganizationController {
+    private readonly service;
+    constructor(service: ReturnType<typeof createIdentityOrganizationProvider>);
+    index(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>;
+    store(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;
+    }>;
+}

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

@@ -0,0 +1,18 @@
+export class IdentityOrganizationController {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    index(actor, query) {
+        return this.service.list(actor, query);
+    }
+    show(actor, id) {
+        return this.service.show(actor, id);
+    }
+    store(actor, raw) {
+        return this.service.create(actor, raw);
+    }
+    update(actor, id, raw) {
+        return this.service.update(actor, id, raw);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,46 @@
+import type { Kysely, Transaction } from "kysely";
+import type { IdentityMutation, IdentitySchema } from "../identity.types.js";
+import { organizationNameSource } from "./organization.repository.js";
+import type { IdentityTenantDirectory } from "./organization.types.js";
+/** Read-only server contract for modules that depend on active tenant identity. */
+export declare function createIdentityTenantDirectory(database: Kysely<IdentitySchema>): IdentityTenantDirectory;
+export declare function createIdentityOrganizationProvider(database: Kysely<IdentitySchema>, mutate: IdentityMutation, revokeTenantSessions: (trx: Transaction<IdentitySchema>, tenantId: string) => Promise<void>): Readonly<{
+    verify: () => Promise<void>;
+    tenantIds: (trx: Transaction<IdentitySchema>) => Promise<string[]>;
+    active: (trx: Transaction<IdentitySchema>, id: string) => Promise<{
+        id: string;
+    } | undefined>;
+    activeDetail: (db: Kysely<IdentitySchema>, id: string) => Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+    nameSource: typeof organizationNameSource;
+    list: (actor: import("../identity.types.js").Principal, query: import("../index.js").IdentityListQuery) => Promise<{
+        data: {
+            active: boolean;
+            version: number;
+        }[];
+        meta: {
+            page: number;
+            perPage: number;
+            total: number;
+            lastPage: number;
+        };
+    }>;
+    show: (actor: import("../identity.types.js").Principal, id: string) => Promise<{
+        active: boolean;
+        version: number;
+    } | undefined>;
+    create: (actor: import("../identity.types.js").Principal, raw: unknown) => Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        version: number;
+    }>;
+    update: (actor: import("../identity.types.js").Principal, id: string, raw: unknown) => Promise<{
+        active: boolean;
+        version: number;
+        id: string;
+        name: string;
+    }>;
+}>;

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

@@ -0,0 +1,33 @@
+import { IdentityOrganizationRepository, organizationNameSource } from "./organization.repository.js";
+import { IdentityOrganizationService } from "./organization.service.js";
+import { z } from "zod";
+/** Read-only server contract for modules that depend on active tenant identity. */
+export function createIdentityTenantDirectory(database) {
+    const repository = new IdentityOrganizationRepository(database);
+    return {
+        active(id) {
+            z.string().min(1).max(255).parse(id);
+            return repository.activeDetail(database, id);
+        },
+        listActive(after, pageSize) {
+            z.string().max(255).parse(after);
+            z.number().int().min(1).max(500).parse(pageSize);
+            return repository.listActive(after, pageSize);
+        }
+    };
+}
+export function createIdentityOrganizationProvider(database, mutate, revokeTenantSessions) {
+    const repository = new IdentityOrganizationRepository(database);
+    const service = new IdentityOrganizationService(repository, mutate, revokeTenantSessions);
+    return Object.freeze({
+        verify: repository.verifySchema.bind(repository),
+        tenantIds: repository.tenantIds.bind(repository),
+        active: repository.active.bind(repository),
+        activeDetail: repository.activeDetail.bind(repository),
+        nameSource: organizationNameSource,
+        list: service.list.bind(service),
+        show: service.show.bind(service),
+        create: service.create.bind(service),
+        update: service.update.bind(service)
+    });
+}

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

@@ -0,0 +1,58 @@
+import { type Kysely, type Transaction } from "kysely";
+import type { IdentitySchema, Principal } from "../identity.types.js";
+import type { IdentityListQuery } from "../support/pagination.schema.js";
+export declare const organizationNameSource: () => import("kysely").RawBuilder<unknown>;
+export declare class IdentityOrganizationRepository {
+    private readonly db;
+    constructor(db: Kysely<IdentitySchema>);
+    verifySchema(): Promise<void>;
+    tenantIds(trx: Transaction<IdentitySchema>): Promise<string[]>;
+    active(trx: Transaction<IdentitySchema>, id: string): Promise<{
+        id: string;
+    } | undefined>;
+    activeDetail(db: Kysely<IdentitySchema>, id: string): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+    listActive(after: string, pageSize: number): Promise<{
+        id: string;
+    }[]>;
+    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>;
+    exists(trx: Transaction<IdentitySchema>, id: string): Promise<{
+        id: string;
+    } | undefined>;
+    version(trx: Transaction<IdentitySchema>, id: string): Promise<{
+        version: number;
+    }>;
+    create(trx: Transaction<IdentitySchema>, input: {
+        id: string;
+        name: string;
+        active: boolean;
+    }): Promise<void>;
+    update(trx: Transaction<IdentitySchema>, id: string, input: {
+        name?: string;
+        active?: boolean;
+        expectedVersion: number;
+    }): Promise<boolean>;
+    get(trx: Transaction<IdentitySchema>, id: string): Promise<{
+        active: number;
+        id: string;
+        name: string;
+        version: number;
+    }>;
+}

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

@@ -0,0 +1,101 @@
+import { sql } from "kysely";
+import { listRows, showRow } from "../support/pagination.js";
+function organizationListSource(actor) {
+    return sql `select id,name,active,version from identity_tenants ${actor.portal === "super-admin" ? sql `` : sql `where id=${actor.tenant.id}`}`;
+}
+export const organizationNameSource = () => sql `select id,name from identity_tenants`;
+export class IdentityOrganizationRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async verifySchema() {
+        await this.db.selectFrom("identity_tenants").select("version").limit(1).execute();
+    }
+    async tenantIds(trx) {
+        const rows = await trx.selectFrom("identity_tenants").select("id").execute();
+        return rows.map((row) => row.id);
+    }
+    active(trx, id) {
+        return trx
+            .selectFrom("identity_tenants")
+            .select("id")
+            .where("id", "=", id)
+            .where("active", "=", 1)
+            .executeTakeFirst();
+    }
+    activeDetail(db, id) {
+        return db
+            .selectFrom("identity_tenants")
+            .select(["id", "name"])
+            .where("id", "=", id)
+            .where("active", "=", 1)
+            .executeTakeFirst();
+    }
+    listActive(after, pageSize) {
+        return this.db
+            .selectFrom("identity_tenants")
+            .select("id")
+            .where("active", "=", 1)
+            .where("id", ">", after)
+            .orderBy("id")
+            .limit(pageSize)
+            .execute();
+    }
+    list(actor, query) {
+        const present = (row) => ({
+            ...row,
+            active: Boolean(row.active),
+            version: Number(row.version)
+        });
+        return listRows(this.db, organizationListSource(actor), ["id", "name"], query, present);
+    }
+    show(actor, id) {
+        const present = (row) => ({
+            ...row,
+            active: Boolean(row.active),
+            version: Number(row.version)
+        });
+        return showRow(this.db, organizationListSource(actor), id, present);
+    }
+    exists(trx, id) {
+        return trx.selectFrom("identity_tenants").select("id").where("id", "=", id).executeTakeFirst();
+    }
+    version(trx, id) {
+        return trx
+            .selectFrom("identity_tenants")
+            .select("version")
+            .where("id", "=", id)
+            .executeTakeFirstOrThrow();
+    }
+    async create(trx, input) {
+        await trx
+            .insertInto("identity_tenants")
+            .values({
+            id: input.id,
+            name: input.name,
+            active: Number(input.active)
+        })
+            .execute();
+    }
+    async update(trx, id, input) {
+        const updated = await trx
+            .updateTable("identity_tenants")
+            .set({
+            name: input.name,
+            active: input.active === undefined ? undefined : Number(input.active),
+            version: sql `version + 1`
+        })
+            .where("id", "=", id)
+            .where("version", "=", input.expectedVersion)
+            .executeTakeFirst();
+        return updated.numUpdatedRows === 1n;
+    }
+    async get(trx, id) {
+        return trx
+            .selectFrom("identity_tenants")
+            .selectAll()
+            .where("id", "=", id)
+            .executeTakeFirstOrThrow();
+    }
+}

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

@@ -0,0 +1,5 @@
+export declare const organizationResource: "organizations";
+export declare const organizationResourceRoute: (controller: import("./organization.controller.js").IdentityOrganizationController) => {
+    resource: "organizations";
+    controller: import("./organization.controller.js").IdentityOrganizationController;
+};

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

@@ -0,0 +1,2 @@
+export const organizationResource = "organizations";
+export const organizationResourceRoute = (controller) => ({ resource: organizationResource, controller });

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const organizationCreateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const organizationUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strict>;

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { identityKeySchema } from "../support/identity.schema.js";
+const name = z.string().trim().min(1).max(100);
+export const organizationCreateSchema = z
+    .object({
+    id: identityKeySchema,
+    name,
+    active: z.boolean().default(true)
+})
+    .strict();
+export const organizationUpdateSchema = z
+    .object({
+    name: name.optional(),
+    active: z.boolean().optional(),
+    expectedVersion: z.number().int().min(0)
+})
+    .strict()
+    .refine((value) => Object.keys(value).length > 1, "Provide a changed field.");

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

@@ -0,0 +1,3 @@
+import type { Transaction } from "kysely";
+import type { IdentitySchema } from "../identity.types.js";
+export declare function seedOrganization(trx: Transaction<IdentitySchema>, env: NodeJS.ProcessEnv): Promise<void>;