@plumix/core 0.1.0

package/dist/rpc/procedures/auth/api-tokens/index.d.ts

@@ -0,0 +1,385 @@
+export declare const apiTokensRouter: {
+    readonly list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").OptionalSchema<import("valibot").ObjectSchema<{}, undefined>, {}>, import("@orpc/server").Schema<{
+        id: string;
+        name: string;
+        prefix: string;
+        expiresAt: Date | null;
+        lastUsedAt: Date | null;
+        createdAt: Date;
+        scopes: readonly string[] | null;
+    }[], {
+        id: string;
+        name: string;
+        prefix: string;
+        expiresAt: Date | null;
+        lastUsedAt: Date | null;
+        createdAt: Date;
+        scopes: readonly string[] | null;
+    }[]>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+    readonly create: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, "name must be non-empty">, import("valibot").MaxLengthAction<string, 64, "name must be ≤ 64 chars">, import("valibot").RegexAction<string, "name must not contain newlines">]>;
+        readonly expiresInDays: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").NullSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>], undefined>, 90>;
+        readonly scopes: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").NullSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, "capability must be non-empty">, import("valibot").MaxLengthAction<string, 96, "capability must be ≤ 96 chars">, import("valibot").RegexAction<string, "capability uses [A-Za-z0-9_:.\\-*] only">]>, undefined>, import("valibot").MaxLengthAction<string[], 128, "≤ 128 scopes">]>], undefined>, null>;
+    }, undefined>, import("@orpc/server").Schema<{
+        secret: string;
+        token: {
+            id: string;
+            name: string;
+            prefix: string;
+            expiresAt: Date | null;
+            lastUsedAt: Date | null;
+            createdAt: Date;
+            scopes: readonly string[] | null;
+        };
+    }, {
+        secret: string;
+        token: {
+            id: string;
+            name: string;
+            prefix: string;
+            expiresAt: Date | null;
+            lastUsedAt: Date | null;
+            createdAt: Date;
+            scopes: readonly string[] | null;
+        };
+    }>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+    readonly revoke: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+        readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 128, undefined>]>;
+    }, undefined>, import("@orpc/server").Schema<{
+        id: string;
+    }, {
+        id: string;
+    }>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+    readonly adminList: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly userId: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly limit: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 200, undefined>]>, 50>;
+        readonly offset: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, 0>;
+        readonly includeRevoked: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, false>;
+    }, undefined>, {}>, import("@orpc/server").Schema<{
+        items: {
+            id: string;
+            name: string;
+            prefix: string;
+            scopes: readonly string[] | null;
+            expiresAt: Date | null;
+            lastUsedAt: Date | null;
+            createdAt: Date;
+            revokedAt: Date | null;
+            user: {
+                id: number;
+                email: string;
+                name: string | null;
+            };
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }, {
+        items: {
+            id: string;
+            name: string;
+            prefix: string;
+            scopes: readonly string[] | null;
+            expiresAt: Date | null;
+            lastUsedAt: Date | null;
+            createdAt: Date;
+            revokedAt: Date | null;
+            user: {
+                id: number;
+                email: string;
+                name: string | null;
+            };
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+    readonly adminRevoke: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+        readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 128, undefined>]>;
+    }, undefined>, import("@orpc/server").Schema<{
+        id: string;
+    }, {
+        id: string;
+    }>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/rpc/procedures/auth/api-tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/api-tokens/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC"}

package/dist/rpc/procedures/auth/api-tokens/index.js

@@ -0,0 +1,13 @@
+import { adminList } from "./admin-list.js";
+import { adminRevoke } from "./admin-revoke.js";
+import { create } from "./create.js";
+import { list } from "./list.js";
+import { revoke } from "./revoke.js";
+export const apiTokensRouter = {
+    list,
+    create,
+    revoke,
+    adminList,
+    adminRevoke,
+};
+//# sourceMappingURL=index.js.map

package/dist/rpc/procedures/auth/api-tokens/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/api-tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI;IACJ,MAAM;IACN,MAAM;IACN,SAAS;IACT,WAAW;CACH,CAAC"}

package/dist/rpc/procedures/auth/api-tokens/list.d.ts

@@ -0,0 +1,74 @@
+export declare const list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").OptionalSchema<import("valibot").ObjectSchema<{}, undefined>, {}>, import("@orpc/server").Schema<{
+    id: string;
+    name: string;
+    prefix: string;
+    expiresAt: Date | null;
+    lastUsedAt: Date | null;
+    createdAt: Date;
+    scopes: readonly string[] | null;
+}[], {
+    id: string;
+    name: string;
+    prefix: string;
+    expiresAt: Date | null;
+    lastUsedAt: Date | null;
+    createdAt: Date;
+    scopes: readonly string[] | null;
+}[]>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+    readonly UNAUTHORIZED: {
+        readonly message: "Authentication required";
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Invalid input";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly FORBIDDEN: {
+        readonly message: "Permission denied";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly capability: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly NOT_FOUND: {
+        readonly message: "Resource not found";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+        }, undefined>;
+    };
+    readonly CONFLICT: {
+        readonly message: "Resource conflict";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+            readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly message: "Payload too large";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly limit: import("valibot").NumberSchema<undefined>;
+            readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly message: "Unsupported media type";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly mime: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly INVALID_BLOCK_CONTENT: {
+        readonly message: "Block content failed registry validation";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+}>, Record<never, never>>;
+//# sourceMappingURL=list.d.ts.map

package/dist/rpc/procedures/auth/api-tokens/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/api-tokens/list.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAmBb,CAAC"}

package/dist/rpc/procedures/auth/api-tokens/list.js

@@ -0,0 +1,32 @@
+import { and, desc, eq, isNull } from "../../../../db/index.js";
+import { apiTokens } from "../../../../db/schema/api_tokens.js";
+import { authenticated } from "../../../authenticated.js";
+import { base } from "../../../base.js";
+import { apiTokensListInputSchema } from "./schemas.js";
+// Returns the *current user's* personal access tokens. Self-scoped —
+// no capability check; users always see their own tokens. Filters out
+// revoked rows by default (revoked tokens stay in the DB for a future
+// audit-log surface but don't clutter the management UI).
+//
+// Never returns the secret — that's only available at create time.
+// The `prefix` field carries the recognisable fragment for UI
+// identification (e.g. `pl_pat_abc1`).
+export const list = base
+    .use(authenticated)
+    .input(apiTokensListInputSchema)
+    .handler(async ({ context }) => {
+    return context.db
+        .select({
+        id: apiTokens.id,
+        name: apiTokens.name,
+        prefix: apiTokens.prefix,
+        expiresAt: apiTokens.expiresAt,
+        lastUsedAt: apiTokens.lastUsedAt,
+        createdAt: apiTokens.createdAt,
+        scopes: apiTokens.scopes,
+    })
+        .from(apiTokens)
+        .where(and(eq(apiTokens.userId, context.user.id), isNull(apiTokens.revokedAt)))
+        .orderBy(desc(apiTokens.createdAt));
+});
+//# sourceMappingURL=list.js.map

package/dist/rpc/procedures/auth/api-tokens/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/api-tokens/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAExD,qEAAqE;AACrE,sEAAsE;AACtE,sEAAsE;AACtE,0DAA0D;AAC1D,EAAE;AACF,mEAAmE;AACnE,8DAA8D;AAC9D,uCAAuC;AACvC,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI;KACrB,GAAG,CAAC,aAAa,CAAC;KAClB,KAAK,CAAC,wBAAwB,CAAC;KAC/B,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;IAC7B,OAAO,OAAO,CAAC,EAAE;SACd,MAAM,CAAC;QACN,EAAE,EAAE,SAAS,CAAC,EAAE;QAChB,IAAI,EAAE,SAAS,CAAC,IAAI;QACpB,MAAM,EAAE,SAAS,CAAC,MAAM;QACxB,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,UAAU,EAAE,SAAS,CAAC,UAAU;QAChC,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,MAAM,EAAE,SAAS,CAAC,MAAM;KACzB,CAAC;SACD,IAAI,CAAC,SAAS,CAAC;SACf,KAAK,CACJ,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CACxE;SACA,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC,CAAC"}

package/dist/rpc/procedures/auth/api-tokens/revoke.d.ts

@@ -0,0 +1,64 @@
+export declare const revoke: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContextBase<typeof import("../../../../db/schema/index.js")> & import("../../../../index.js").AppContextExtensions & Record<never, never>, import("../../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../../index.js").AppContext, import("../../../../index.js").AuthenticatedAppContext<typeof import("../../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+    readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 128, undefined>]>;
+}, undefined>, import("@orpc/server").Schema<{
+    id: string;
+}, {
+    id: string;
+}>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+    readonly UNAUTHORIZED: {
+        readonly message: "Authentication required";
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Invalid input";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly FORBIDDEN: {
+        readonly message: "Permission denied";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly capability: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly NOT_FOUND: {
+        readonly message: "Resource not found";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+        }, undefined>;
+    };
+    readonly CONFLICT: {
+        readonly message: "Resource conflict";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+            readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly message: "Payload too large";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly limit: import("valibot").NumberSchema<undefined>;
+            readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly message: "Unsupported media type";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly mime: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly INVALID_BLOCK_CONTENT: {
+        readonly message: "Block content failed registry validation";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+}>, Record<never, never>>;
+//# sourceMappingURL=revoke.d.ts.map

package/dist/rpc/procedures/auth/api-tokens/revoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revoke.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/api-tokens/revoke.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAiBf,CAAC"}

package/dist/rpc/procedures/auth/api-tokens/revoke.js

@@ -0,0 +1,27 @@
+import { revokeApiToken } from "../../../../auth/api-tokens.js";
+import { authenticated } from "../../../authenticated.js";
+import { base } from "../../../base.js";
+import { apiTokensRevokeInputSchema } from "./schemas.js";
+// Soft-delete (sets `revokedAt`) the user's own token. Cross-user
+// attempts return NOT_FOUND with no oracle — the underlying primitive
+// pins both `id` AND `userId` in the WHERE clause and returns false
+// when no row matched.
+//
+// Idempotent: revoking an already-revoked token still surfaces
+// NOT_FOUND from the user's perspective (the row is filtered by
+// `revokedAt IS NULL`), which keeps the wire shape simple.
+export const revoke = base
+    .use(authenticated)
+    .input(apiTokensRevokeInputSchema)
+    .handler(async ({ input, context, errors }) => {
+    const ok = await revokeApiToken(context.db, {
+        id: input.id,
+        userId: context.user.id,
+    });
+    if (!ok) {
+        throw errors.NOT_FOUND({ data: { kind: "api_token", id: input.id } });
+    }
+    await context.hooks.doAction("api_token:revoked", { id: input.id, userId: context.user.id }, { actor: context.user, mode: "self" });
+    return { id: input.id };
+});
+//# sourceMappingURL=revoke.js.map

package/dist/rpc/procedures/auth/api-tokens/revoke.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revoke.js","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/api-tokens/revoke.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAE1D,kEAAkE;AAClE,sEAAsE;AACtE,oEAAoE;AACpE,uBAAuB;AACvB,EAAE;AACF,+DAA+D;AAC/D,gEAAgE;AAChE,2DAA2D;AAC3D,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI;KACvB,GAAG,CAAC,aAAa,CAAC;KAClB,KAAK,CAAC,0BAA0B,CAAC;KACjC,OAAO,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE;IAC5C,MAAM,EAAE,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE;QAC1C,EAAE,EAAE,KAAK,CAAC,EAAE;QACZ,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE;KACxB,CAAC,CAAC;IACH,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,MAAM,MAAM,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IACxE,CAAC;IACD,MAAM,OAAO,CAAC,KAAK,CAAC,QAAQ,CAC1B,mBAAmB,EACnB,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EACzC,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CACtC,CAAC;IACF,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;AAC1B,CAAC,CAAC,CAAC"}