@devxcrew/platform 0.1.2 → 0.1.6

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

@@ -0,0 +1,27 @@
+import { IdentityError } from "../support/identity.error.js";
+export class IdentitySessionService {
+    repository;
+    mutate;
+    constructor(repository, mutate) {
+        this.repository = repository;
+        this.mutate = mutate;
+    }
+    list(actor, query) {
+        this.allow(actor);
+        return this.repository.list(actor, query);
+    }
+    show(actor, id) {
+        this.allow(actor);
+        return this.repository.show(actor, id);
+    }
+    async remove(actor, id) {
+        const row = await this.show(actor, id);
+        if (!row)
+            throw new IdentityError(404, "Resource not found.");
+        await this.mutate(actor, "sessions", id, (trx) => this.repository.revokeOne(trx, actor.appId, id));
+    }
+    allow(actor) {
+        if (actor.portal !== "user" && !actor.permissions.includes("identity.manage"))
+            throw new IdentityError(403, "Access denied.");
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Portal } from "../identity.types.js";
+export interface IdentitySessionTables {
+    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;
+    };
+}
+export type IdentitySessionRow = IdentitySessionTables["identity_sessions"];

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

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

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

@@ -0,0 +1,5 @@
+export { createIdentitySettingsProvider } from "./settings.provider.js";
+export { settingsSchema, securitySettingsSchema } from "./settings.schema.js";
+export { settingsPaths } from "./settings.routes.js";
+export type { IdentitySettingsRow, IdentityAppSettingsRow } from "./settings.types.js";
+export { IdentitySettingsController } from "./settings.controller.js";

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

@@ -0,0 +1,4 @@
+export { createIdentitySettingsProvider } from "./settings.provider.js";
+export { settingsSchema, securitySettingsSchema } from "./settings.schema.js";
+export { settingsPaths } from "./settings.routes.js";
+export { IdentitySettingsController } from "./settings.controller.js";

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

@@ -0,0 +1,35 @@
+import type { Principal } from "../identity.types.js";
+import type { createIdentitySettingsProvider } from "./settings.provider.js";
+export declare class IdentitySettingsController {
+    private readonly service;
+    constructor(service: ReturnType<typeof createIdentitySettingsProvider>);
+    configuration(appId: string, requiresOrganizationId: boolean): Promise<{
+        displayName: string;
+        requiresOrganizationId: boolean;
+    }>;
+    presentation(actor: Principal): Promise<{
+        displayName: string;
+        organizationDisplayName: string;
+        locale: string;
+        timeZone: string;
+    }>;
+    organization(actor: Principal, raw?: unknown): Promise<{
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }>;
+    application(actor: Principal, security: boolean, raw: unknown, fallbackSeconds: number): Promise<{
+        sessionSeconds: number;
+        version: number;
+        displayName?: undefined;
+        locale?: undefined;
+        timeZone?: undefined;
+    } | {
+        sessionSeconds?: undefined;
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }>;
+}

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

@@ -0,0 +1,18 @@
+export class IdentitySettingsController {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    configuration(appId, requiresOrganizationId) {
+        return this.service.configuration(appId, requiresOrganizationId);
+    }
+    presentation(actor) {
+        return this.service.presentation(actor);
+    }
+    organization(actor, raw) {
+        return this.service.organizationSettings(actor, raw);
+    }
+    application(actor, security, raw, fallbackSeconds) {
+        return this.service.applicationSettings(actor, security, raw, fallbackSeconds);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,35 @@
+import type { Kysely, Transaction } from "kysely";
+import type { IdentityMutation, IdentitySchema } from "../identity.types.js";
+export declare function createIdentitySettingsProvider(database: Kysely<IdentitySchema>, appName: string, mutate: IdentityMutation, revokeAppSessions: (trx: Transaction<IdentitySchema>, appId: string) => Promise<void>): Readonly<{
+    verify: () => Promise<void>;
+    sessionSeconds: (appId: string, fallback: number) => Promise<number>;
+    configuration: (appId: string, requiresOrganizationId: boolean) => Promise<{
+        displayName: string;
+        requiresOrganizationId: boolean;
+    }>;
+    presentation: (actor: import("../identity.types.js").Principal) => Promise<{
+        displayName: string;
+        organizationDisplayName: string;
+        locale: string;
+        timeZone: string;
+    }>;
+    organizationSettings: (actor: import("../identity.types.js").Principal, raw?: unknown) => Promise<{
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }>;
+    applicationSettings: (actor: import("../identity.types.js").Principal, security: boolean, raw: unknown, fallbackSeconds: number) => Promise<{
+        sessionSeconds: number;
+        version: number;
+        displayName?: undefined;
+        locale?: undefined;
+        timeZone?: undefined;
+    } | {
+        sessionSeconds?: undefined;
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }>;
+}>;

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

@@ -0,0 +1,14 @@
+import { IdentitySettingsRepository } from "./settings.repository.js";
+import { IdentitySettingsService } from "./settings.service.js";
+export function createIdentitySettingsProvider(database, appName, mutate, revokeAppSessions) {
+    const repository = new IdentitySettingsRepository(database);
+    const service = new IdentitySettingsService(repository, appName, mutate, revokeAppSessions);
+    return Object.freeze({
+        verify: repository.verifySchema.bind(repository),
+        sessionSeconds: repository.sessionSeconds.bind(repository),
+        configuration: service.configuration.bind(service),
+        presentation: service.presentation.bind(service),
+        organizationSettings: service.organizationSettings.bind(service),
+        applicationSettings: service.applicationSettings.bind(service)
+    });
+}

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

@@ -0,0 +1,49 @@
+import type { Kysely, Transaction } from "kysely";
+import type { IdentitySchema } from "../identity.types.js";
+export declare class IdentitySettingsRepository {
+    private readonly db;
+    constructor(db: Kysely<IdentitySchema>);
+    verifySchema(): Promise<void>;
+    app(appId: string): Promise<{
+        app_id: string;
+        display_name: string;
+        locale: string;
+        session_seconds: number;
+        time_zone: string;
+        version: number;
+    } | undefined>;
+    sessionSeconds(appId: string, fallback: number): Promise<number>;
+    organization(tenantId: string): Promise<{
+        display_name: string;
+        locale: string;
+        tenant_id: string;
+        time_zone: string;
+        version: number;
+    } | undefined>;
+    appInTransaction(trx: Transaction<IdentitySchema>, appId: string): Promise<{
+        app_id: string;
+        display_name: string;
+        locale: string;
+        session_seconds: number;
+        time_zone: string;
+        version: number;
+    } | undefined>;
+    organizationInTransaction(trx: Transaction<IdentitySchema>, tenantId: string): Promise<{
+        version: number;
+    } | undefined>;
+    saveOrganization(trx: Transaction<IdentitySchema>, input: {
+        tenantId: string;
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }): Promise<void>;
+    saveApp(trx: Transaction<IdentitySchema>, row: {
+        app_id: string;
+        display_name: string;
+        locale: string;
+        time_zone: string;
+        session_seconds: number;
+        version: number;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,75 @@
+export class IdentitySettingsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async verifySchema() {
+        await this.db.selectFrom("identity_settings").select("version").limit(1).execute();
+        await this.db
+            .selectFrom("identity_app_settings")
+            .select(["version", "session_seconds"])
+            .limit(1)
+            .execute();
+    }
+    app(appId) {
+        return this.db
+            .selectFrom("identity_app_settings")
+            .selectAll()
+            .where("app_id", "=", appId)
+            .executeTakeFirst();
+    }
+    async sessionSeconds(appId, fallback) {
+        const row = await this.db
+            .selectFrom("identity_app_settings")
+            .select("session_seconds")
+            .where("app_id", "=", appId)
+            .executeTakeFirst();
+        return Number(row?.session_seconds ?? fallback);
+    }
+    organization(tenantId) {
+        return this.db
+            .selectFrom("identity_settings")
+            .selectAll()
+            .where("tenant_id", "=", tenantId)
+            .executeTakeFirst();
+    }
+    appInTransaction(trx, appId) {
+        return trx
+            .selectFrom("identity_app_settings")
+            .selectAll()
+            .where("app_id", "=", appId)
+            .executeTakeFirst();
+    }
+    organizationInTransaction(trx, tenantId) {
+        return trx
+            .selectFrom("identity_settings")
+            .select("version")
+            .where("tenant_id", "=", tenantId)
+            .executeTakeFirst();
+    }
+    async saveOrganization(trx, input) {
+        await trx
+            .insertInto("identity_settings")
+            .values({
+            tenant_id: input.tenantId,
+            display_name: input.displayName,
+            locale: input.locale,
+            time_zone: input.timeZone,
+            version: input.version
+        })
+            .onConflict((c) => c.column("tenant_id").doUpdateSet({
+            display_name: input.displayName,
+            locale: input.locale,
+            time_zone: input.timeZone,
+            version: input.version
+        }))
+            .execute();
+    }
+    async saveApp(trx, row) {
+        await trx
+            .insertInto("identity_app_settings")
+            .values(row)
+            .onConflict((c) => c.column("app_id").doUpdateSet(row))
+            .execute();
+    }
+}

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

@@ -0,0 +1 @@
+export declare const settingsPaths: readonly ["configuration", "presentation", "settings", "application-settings", "security-settings"];

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

@@ -0,0 +1,7 @@
+export const settingsPaths = [
+    "configuration",
+    "presentation",
+    "settings",
+    "application-settings",
+    "security-settings"
+];

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const settingsSchema: z.ZodObject<{
+    displayName: z.ZodString;
+    expectedVersion: z.ZodNumber;
+    locale: z.ZodEnum<{
+        en: "en";
+        "en-GB": "en-GB";
+        "en-US": "en-US";
+    }>;
+    timeZone: z.ZodString;
+}, z.core.$strict>;
+export declare const securitySettingsSchema: z.ZodObject<{
+    sessionSeconds: z.ZodNumber;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strict>;

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+const name = z.string().trim().min(1).max(100);
+export const settingsSchema = z
+    .object({
+    displayName: name,
+    expectedVersion: z.number().int().min(0),
+    locale: z.enum(["en", "en-US", "en-GB"]),
+    timeZone: z
+        .string()
+        .max(100)
+        .refine((value) => {
+        try {
+            new Intl.DateTimeFormat("en", { timeZone: value });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, "Use a supported IANA time zone.")
+})
+    .strict();
+export const securitySettingsSchema = z
+    .object({
+    sessionSeconds: z.number().int().min(300).max(86400),
+    expectedVersion: z.number().int().min(0)
+})
+    .strict();

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

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

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

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

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

@@ -0,0 +1,40 @@
+import type { Transaction } from "kysely";
+import type { IdentityMutation, IdentitySchema, Principal } from "../identity.types.js";
+import { IdentitySettingsRepository } from "./settings.repository.js";
+export declare class IdentitySettingsService {
+    private readonly repository;
+    private readonly appName;
+    private readonly mutate;
+    private readonly revokeAppSessions;
+    constructor(repository: IdentitySettingsRepository, appName: string, mutate: IdentityMutation, revokeAppSessions: (trx: Transaction<IdentitySchema>, appId: string) => Promise<void>);
+    configuration(appId: string, requiresOrganizationId: boolean): Promise<{
+        displayName: string;
+        requiresOrganizationId: boolean;
+    }>;
+    presentation(actor: Principal): Promise<{
+        displayName: string;
+        organizationDisplayName: string;
+        locale: string;
+        timeZone: string;
+    }>;
+    organizationSettings(actor: Principal, raw?: unknown): Promise<{
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }>;
+    applicationSettings(actor: Principal, security: boolean, raw: unknown, fallbackSeconds: number): Promise<{
+        sessionSeconds: number;
+        version: number;
+        displayName?: undefined;
+        locale?: undefined;
+        timeZone?: undefined;
+    } | {
+        sessionSeconds?: undefined;
+        displayName: string;
+        locale: string;
+        timeZone: string;
+        version: number;
+    }>;
+    private revision;
+}

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

@@ -0,0 +1,101 @@
+import { IdentityError } from "../support/identity.error.js";
+import { securitySettingsSchema, settingsSchema } from "./settings.schema.js";
+export class IdentitySettingsService {
+    repository;
+    appName;
+    mutate;
+    revokeAppSessions;
+    constructor(repository, appName, mutate, revokeAppSessions) {
+        this.repository = repository;
+        this.appName = appName;
+        this.mutate = mutate;
+        this.revokeAppSessions = revokeAppSessions;
+    }
+    async configuration(appId, requiresOrganizationId) {
+        const app = await this.repository.app(appId);
+        return { displayName: app?.display_name ?? this.appName, requiresOrganizationId };
+    }
+    async presentation(actor) {
+        const app = await this.repository.app(actor.appId);
+        const organization = await this.repository.organization(actor.tenant.id);
+        return {
+            displayName: app?.display_name ?? this.appName,
+            organizationDisplayName: organization?.display_name ?? actor.tenant.name,
+            locale: organization?.locale ?? app?.locale ?? "en",
+            timeZone: organization?.time_zone ?? app?.time_zone ?? "UTC"
+        };
+    }
+    async organizationSettings(actor, raw) {
+        if (raw !== undefined) {
+            if (actor.portal === "user" || !actor.permissions.includes("identity.manage"))
+                throw new IdentityError(403, "Access denied.");
+            const input = settingsSchema.parse(raw);
+            await this.mutate(actor, "settings", actor.tenant.id, async (trx) => {
+                const current = await this.repository.organizationInTransaction(trx, actor.tenant.id);
+                this.revision(current?.version ?? 0, input.expectedVersion);
+                await this.repository.saveOrganization(trx, {
+                    tenantId: actor.tenant.id,
+                    displayName: input.displayName,
+                    locale: input.locale,
+                    timeZone: input.timeZone,
+                    version: input.expectedVersion + 1
+                });
+            });
+        }
+        const organization = await this.repository.organization(actor.tenant.id);
+        const presentation = await this.presentation(actor);
+        return {
+            displayName: presentation.organizationDisplayName,
+            locale: presentation.locale,
+            timeZone: presentation.timeZone,
+            version: Number(organization?.version ?? 0)
+        };
+    }
+    async applicationSettings(actor, security, raw, fallbackSeconds) {
+        if (actor.portal === "user")
+            throw new IdentityError(403, "Access denied.");
+        if (raw !== undefined) {
+            if (actor.portal !== "super-admin" || !actor.permissions.includes("identity.manage"))
+                throw new IdentityError(403, "Access denied.");
+            const input = security ? securitySettingsSchema.parse(raw) : settingsSchema.parse(raw);
+            await this.mutate(actor, security ? "security-settings" : "application-settings", actor.appId, async (trx) => {
+                const current = await this.repository.appInTransaction(trx, actor.appId);
+                this.revision(current?.version ?? 0, input.expectedVersion);
+                const row = {
+                    app_id: actor.appId,
+                    display_name: current?.display_name ?? this.appName,
+                    locale: current?.locale ?? "en",
+                    time_zone: current?.time_zone ?? "UTC",
+                    session_seconds: current?.session_seconds ?? fallbackSeconds,
+                    version: input.expectedVersion + 1
+                };
+                if ("sessionSeconds" in input)
+                    row.session_seconds = input.sessionSeconds;
+                else {
+                    row.display_name = input.displayName;
+                    row.locale = input.locale;
+                    row.time_zone = input.timeZone;
+                }
+                await this.repository.saveApp(trx, row);
+                if (security)
+                    await this.revokeAppSessions(trx, actor.appId);
+            });
+        }
+        const row = await this.repository.app(actor.appId);
+        return security
+            ? {
+                sessionSeconds: Number(row?.session_seconds ?? fallbackSeconds),
+                version: Number(row?.version ?? 0)
+            }
+            : {
+                displayName: row?.display_name ?? this.appName,
+                locale: row?.locale ?? "en",
+                timeZone: row?.time_zone ?? "UTC",
+                version: Number(row?.version ?? 0)
+            };
+    }
+    revision(current, expected) {
+        if (Number(current) !== expected)
+            throw new IdentityError(409, "This record changed. Reload before saving.");
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { Generated } from "kysely";
+export interface IdentitySettingsTables {
+    identity_settings: {
+        tenant_id: string;
+        display_name: string;
+        locale: string;
+        time_zone: string;
+        version: Generated<number>;
+    };
+    identity_app_settings: {
+        app_id: string;
+        display_name: string;
+        locale: string;
+        time_zone: string;
+        session_seconds: number;
+        version: Generated<number>;
+    };
+}
+export type IdentitySettingsRow = IdentitySettingsTables["identity_settings"];
+export type IdentityAppSettingsRow = IdentitySettingsTables["identity_app_settings"];

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

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

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const portalSchema: z.ZodEnum<{
+    admin: "admin";
+    "super-admin": "super-admin";
+    user: "user";
+}>;
+export declare const identityKeySchema: z.ZodString;
+export declare const resourceIdSchema: z.ZodString;

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export const portalSchema = z.enum(["user", "admin", "super-admin"]);
+export const identityKeySchema = z
+    .string()
+    .regex(/^[a-zA-Z0-9._-]{1,100}$/)
+    .refine((value) => !/^\.+$/.test(value), "Use an identifier with a letter or number.");
+export const resourceIdSchema = z
+    .string()
+    .regex(/^[a-zA-Z0-9._~-]{1,300}$/)
+    .refine((value) => !/^\.+$/.test(value), "Use an identifier with a letter or number.");

package/dist/modules/identity/support/pagination.d.ts

@@ -0,0 +1,13 @@
+import { type Kysely, type RawBuilder } from "kysely";
+import type { IdentitySchema } from "../identity.types.js";
+import type { IdentityListQuery } from "./pagination.schema.js";
+export declare function listRows<T>(db: Kysely<IdentitySchema>, source: RawBuilder<unknown>, fields: readonly string[], query: IdentityListQuery, present: (row: Record<string, unknown>) => T): Promise<{
+    data: T[];
+    meta: {
+        page: number;
+        perPage: number;
+        total: number;
+        lastPage: number;
+    };
+}>;
+export declare function showRow<T>(db: Kysely<IdentitySchema>, source: RawBuilder<unknown>, id: string, present: (row: Record<string, unknown>) => T): Promise<T | undefined>;

package/dist/modules/identity/support/pagination.js

@@ -0,0 +1,27 @@
+import { sql } from "kysely";
+import { IdentityError } from "./identity.error.js";
+export async function listRows(db, source, fields, query, present) {
+    if (!fields.includes(query.sort))
+        throw new IdentityError(422, "This sort field is not supported for this resource.");
+    const search = query.search
+        ? sql `where ${sql.join(fields.map((field) => sql `lower(cast(${sql.ref(field)} as text)) like ${`%${query.search.toLowerCase()}%`}`), sql ` or `)}`
+        : sql ``;
+    const count = await sql `select count(*) as total from (${source}) as resources ${search}`.execute(db);
+    const rows = await sql `select * from (${source}) as resources ${search}
+    order by ${sql.ref(query.sort)} ${query.direction === "asc" ? sql `asc` : sql `desc`}, id asc
+    limit ${query.perPage} offset ${(query.page - 1) * query.perPage}`.execute(db);
+    const total = Number(count.rows[0].total);
+    return {
+        data: rows.rows.map(present),
+        meta: {
+            page: query.page,
+            perPage: query.perPage,
+            total,
+            lastPage: Math.max(1, Math.ceil(total / query.perPage))
+        }
+    };
+}
+export async function showRow(db, source, id, present) {
+    const result = await sql `select * from (${source}) as resources where id = ${id} limit 1`.execute(db);
+    return result.rows[0] ? present(result.rows[0]) : undefined;
+}

package/dist/modules/identity/support/pagination.schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const listSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    perPage: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    search: z.ZodDefault<z.ZodString>;
+    sort: z.ZodDefault<z.ZodEnum<{
+        email: "email";
+        id: "id";
+        name: "name";
+    }>>;
+    direction: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strict>;
+export declare const resourceListQuerySchema: z.ZodPipe<z.ZodObject<{
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    search: z.ZodDefault<z.ZodString>;
+    sort: z.ZodDefault<z.ZodEnum<{
+        email: "email";
+        id: "id";
+        name: "name";
+    }>>;
+    direction: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    per_page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>, z.ZodTransform<{
+    page: number;
+    search: string;
+    sort: "email" | "id" | "name";
+    direction: "asc" | "desc";
+    perPage: number;
+}, {
+    page: number;
+    search: string;
+    sort: "email" | "id" | "name";
+    direction: "asc" | "desc";
+    per_page: number;
+}>>;
+export type IdentityListQuery = z.infer<typeof listSchema>;
+export type IdentityResource = "users" | "organizations" | "memberships" | "roles" | "permissions" | "sessions" | "audit-events";

package/dist/modules/identity/support/pagination.schema.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export const listSchema = z
+    .object({
+    page: z.coerce.number().int().min(1).max(100000).default(1),
+    perPage: z.coerce.number().int().min(1).max(100).default(20),
+    search: z.string().trim().max(100).default(""),
+    sort: z.enum(["id", "name", "email"]).default("id"),
+    direction: z.enum(["asc", "desc"]).default("asc")
+})
+    .strict();
+export const resourceListQuerySchema = listSchema
+    .omit({ perPage: true })
+    .extend({ per_page: listSchema.shape.perPage })
+    .strict()
+    .transform(({ per_page, ...input }) => ({ ...input, perPage: per_page }));