@taico/taico 0.0.2

package/dist/authorization-server/enums/grant-type.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrantType = void 0;
+var GrantType;
+(function (GrantType) {
+    GrantType["AUTHORIZATION_CODE"] = "authorization_code";
+    GrantType["REFRESH_TOKEN"] = "refresh_token";
+})(GrantType || (exports.GrantType = GrantType = {}));
+//# sourceMappingURL=grant-type.enum.js.map

package/dist/authorization-server/enums/grant-type.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grant-type.enum.js","sourceRoot":"","sources":["../../../src/authorization-server/enums/grant-type.enum.ts"],"names":[],"mappings":";;;AAIA,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,sDAAyC,CAAA;IACzC,4CAA+B,CAAA;AACjC,CAAC,EAHW,SAAS,yBAAT,SAAS,QAGpB"}

package/dist/authorization-server/enums/index.d.ts

@@ -0,0 +1,5 @@
+export * from './grant-type.enum';
+export * from './response-type.enum';
+export * from './token-endpoint-auth-method.enum';
+export * from './token-type.enum';
+export * from './token-type-hint.enum';

package/dist/authorization-server/enums/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./grant-type.enum"), exports);
+__exportStar(require("./response-type.enum"), exports);
+__exportStar(require("./token-endpoint-auth-method.enum"), exports);
+__exportStar(require("./token-type.enum"), exports);
+__exportStar(require("./token-type-hint.enum"), exports);
+//# sourceMappingURL=index.js.map

package/dist/authorization-server/enums/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/authorization-server/enums/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,uDAAqC;AACrC,oEAAkD;AAClD,oDAAkC;AAClC,yDAAuC"}

package/dist/authorization-server/enums/response-type.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum ResponseType {
+    CODE = "code"
+}

package/dist/authorization-server/enums/response-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseType = void 0;
+var ResponseType;
+(function (ResponseType) {
+    ResponseType["CODE"] = "code";
+})(ResponseType || (exports.ResponseType = ResponseType = {}));
+//# sourceMappingURL=response-type.enum.js.map

package/dist/authorization-server/enums/response-type.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-type.enum.js","sourceRoot":"","sources":["../../../src/authorization-server/enums/response-type.enum.ts"],"names":[],"mappings":";;;AAGA,IAAY,YAEX;AAFD,WAAY,YAAY;IACtB,6BAAa,CAAA;AACf,CAAC,EAFW,YAAY,4BAAZ,YAAY,QAEvB"}

package/dist/authorization-server/enums/token-endpoint-auth-method.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum TokenEndpointAuthMethod {
+    NONE = "none",
+    CLIENT_SECRET_BASIC = "client_secret_basic"
+}

package/dist/authorization-server/enums/token-endpoint-auth-method.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenEndpointAuthMethod = void 0;
+var TokenEndpointAuthMethod;
+(function (TokenEndpointAuthMethod) {
+    TokenEndpointAuthMethod["NONE"] = "none";
+    TokenEndpointAuthMethod["CLIENT_SECRET_BASIC"] = "client_secret_basic";
+})(TokenEndpointAuthMethod || (exports.TokenEndpointAuthMethod = TokenEndpointAuthMethod = {}));
+//# sourceMappingURL=token-endpoint-auth-method.enum.js.map

package/dist/authorization-server/enums/token-endpoint-auth-method.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-endpoint-auth-method.enum.js","sourceRoot":"","sources":["../../../src/authorization-server/enums/token-endpoint-auth-method.enum.ts"],"names":[],"mappings":";;;AAIA,IAAY,uBAGX;AAHD,WAAY,uBAAuB;IACjC,wCAAa,CAAA;IACb,sEAA2C,CAAA;AAC7C,CAAC,EAHW,uBAAuB,uCAAvB,uBAAuB,QAGlC"}

package/dist/authorization-server/enums/token-type-hint.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum TokenTypeHint {
+    ACCESS_TOKEN = "access_token",
+    REFRESH_TOKEN = "refresh_token"
+}

package/dist/authorization-server/enums/token-type-hint.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTypeHint = void 0;
+var TokenTypeHint;
+(function (TokenTypeHint) {
+    TokenTypeHint["ACCESS_TOKEN"] = "access_token";
+    TokenTypeHint["REFRESH_TOKEN"] = "refresh_token";
+})(TokenTypeHint || (exports.TokenTypeHint = TokenTypeHint = {}));
+//# sourceMappingURL=token-type-hint.enum.js.map

package/dist/authorization-server/enums/token-type-hint.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-type-hint.enum.js","sourceRoot":"","sources":["../../../src/authorization-server/enums/token-type-hint.enum.ts"],"names":[],"mappings":";;;AAIA,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,8CAA6B,CAAA;IAC7B,gDAA+B,CAAA;AACjC,CAAC,EAHW,aAAa,6BAAb,aAAa,QAGxB"}

package/dist/authorization-server/enums/token-type.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum TokenType {
+    BEARER = "Bearer"
+}

package/dist/authorization-server/enums/token-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    TokenType["BEARER"] = "Bearer";
+})(TokenType || (exports.TokenType = TokenType = {}));
+//# sourceMappingURL=token-type.enum.js.map

package/dist/authorization-server/enums/token-type.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-type.enum.js","sourceRoot":"","sources":["../../../src/authorization-server/enums/token-type.enum.ts"],"names":[],"mappings":";;;AAIA,IAAY,SAEX;AAFD,WAAY,SAAS;IACnB,8BAAiB,CAAA;AACnB,CAAC,EAFW,SAAS,yBAAT,SAAS,QAEpB"}

package/dist/authorization-server/errors/authorization.errors.d.ts

@@ -0,0 +1,53 @@
+export declare const AuthorizationErrorCodes: {
+    readonly AUTH_FLOW_NOT_FOUND: "AUTH_FLOW_NOT_FOUND";
+    readonly AUTH_FLOW_ALREADY_COMPLETED: "AUTH_FLOW_ALREADY_COMPLETED";
+    readonly INVALID_FLOW_STATE: "INVALID_FLOW_STATE";
+    readonly SERVER_IDENTIFIER_MISMATCH: "SERVER_IDENTIFIER_MISMATCH";
+    readonly DOWNSTREAM_AUTH_FAILED: "DOWNSTREAM_AUTH_FAILED";
+    readonly NO_PENDING_CONNECTION_FLOWS: "NO_PENDING_CONNECTION_FLOWS";
+    readonly CONNECTION_FLOW_NOT_FOUND: "CONNECTION_FLOW_NOT_FOUND";
+    readonly TOKEN_EXCHANGE_FAILED: "TOKEN_EXCHANGE_FAILED";
+    readonly SERVER_NOT_FOUND: "SERVER_NOT_FOUND";
+    readonly CLIENT_NOT_FOUND: "CLIENT_NOT_FOUND";
+    readonly INVALID_REDIRECT_URI: "INVALID_REDIRECT_URI";
+};
+type AuthorizationErrorCode = (typeof AuthorizationErrorCodes)[keyof typeof AuthorizationErrorCodes];
+export declare abstract class AuthorizationDomainError extends Error {
+    readonly code: AuthorizationErrorCode;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: AuthorizationErrorCode, context?: Record<string, unknown> | undefined);
+}
+export declare class AuthFlowNotFoundError extends AuthorizationDomainError {
+    constructor(flowId: string);
+}
+export declare class AuthFlowAlreadyCompletedError extends AuthorizationDomainError {
+    constructor(flowId: string);
+}
+export declare class InvalidFlowStateError extends AuthorizationDomainError {
+    constructor(reason: string);
+}
+export declare class ServerIdentifierMismatchError extends AuthorizationDomainError {
+    constructor(expected: string, actual: string);
+}
+export declare class DownstreamAuthFailedError extends AuthorizationDomainError {
+    constructor(reason: string);
+}
+export declare class NoPendingConnectionFlowsError extends AuthorizationDomainError {
+    constructor();
+}
+export declare class ConnectionFlowNotFoundError extends AuthorizationDomainError {
+    constructor(state: string);
+}
+export declare class TokenExchangeFailedError extends AuthorizationDomainError {
+    constructor(reason: string);
+}
+export declare class McpServerNotFoundError extends AuthorizationDomainError {
+    constructor(serverIdentifier: string);
+}
+export declare class McpClientNotFoundError extends AuthorizationDomainError {
+    constructor(clientId: string);
+}
+export declare class InvalidRedirectUriError extends AuthorizationDomainError {
+    constructor(redirectUri: string, clientId: string);
+}
+export {};

package/dist/authorization-server/errors/authorization.errors.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidRedirectUriError = exports.McpClientNotFoundError = exports.McpServerNotFoundError = exports.TokenExchangeFailedError = exports.ConnectionFlowNotFoundError = exports.NoPendingConnectionFlowsError = exports.DownstreamAuthFailedError = exports.ServerIdentifierMismatchError = exports.InvalidFlowStateError = exports.AuthFlowAlreadyCompletedError = exports.AuthFlowNotFoundError = exports.AuthorizationDomainError = exports.AuthorizationErrorCodes = void 0;
+const errors_1 = require("@taico/errors");
+exports.AuthorizationErrorCodes = {
+    AUTH_FLOW_NOT_FOUND: errors_1.ErrorCodes.AUTH_FLOW_NOT_FOUND,
+    AUTH_FLOW_ALREADY_COMPLETED: errors_1.ErrorCodes.AUTH_FLOW_ALREADY_COMPLETED,
+    INVALID_FLOW_STATE: errors_1.ErrorCodes.INVALID_FLOW_STATE,
+    SERVER_IDENTIFIER_MISMATCH: errors_1.ErrorCodes.SERVER_IDENTIFIER_MISMATCH,
+    DOWNSTREAM_AUTH_FAILED: errors_1.ErrorCodes.DOWNSTREAM_AUTH_FAILED,
+    NO_PENDING_CONNECTION_FLOWS: errors_1.ErrorCodes.NO_PENDING_CONNECTION_FLOWS,
+    CONNECTION_FLOW_NOT_FOUND: errors_1.ErrorCodes.CONNECTION_FLOW_NOT_FOUND,
+    TOKEN_EXCHANGE_FAILED: errors_1.ErrorCodes.TOKEN_EXCHANGE_FAILED,
+    SERVER_NOT_FOUND: errors_1.ErrorCodes.SERVER_NOT_FOUND,
+    CLIENT_NOT_FOUND: errors_1.ErrorCodes.CLIENT_NOT_FOUND,
+    INVALID_REDIRECT_URI: errors_1.ErrorCodes.INVALID_REDIRECT_URI,
+};
+class AuthorizationDomainError extends Error {
+    code;
+    context;
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = this.constructor.name;
+    }
+}
+exports.AuthorizationDomainError = AuthorizationDomainError;
+class AuthFlowNotFoundError extends AuthorizationDomainError {
+    constructor(flowId) {
+        super('Authorization flow not found.', exports.AuthorizationErrorCodes.AUTH_FLOW_NOT_FOUND, { flowId });
+    }
+}
+exports.AuthFlowNotFoundError = AuthFlowNotFoundError;
+class AuthFlowAlreadyCompletedError extends AuthorizationDomainError {
+    constructor(flowId) {
+        super('Authorization flow has already been completed.', exports.AuthorizationErrorCodes.AUTH_FLOW_ALREADY_COMPLETED, { flowId });
+    }
+}
+exports.AuthFlowAlreadyCompletedError = AuthFlowAlreadyCompletedError;
+class InvalidFlowStateError extends AuthorizationDomainError {
+    constructor(reason) {
+        super(`Invalid flow state: ${reason}`, exports.AuthorizationErrorCodes.INVALID_FLOW_STATE, { reason });
+    }
+}
+exports.InvalidFlowStateError = InvalidFlowStateError;
+class ServerIdentifierMismatchError extends AuthorizationDomainError {
+    constructor(expected, actual) {
+        super('Server identifier mismatch.', exports.AuthorizationErrorCodes.SERVER_IDENTIFIER_MISMATCH, { expected, actual });
+    }
+}
+exports.ServerIdentifierMismatchError = ServerIdentifierMismatchError;
+class DownstreamAuthFailedError extends AuthorizationDomainError {
+    constructor(reason) {
+        super(`One or more downstream connections failed to authorize: ${reason}`, exports.AuthorizationErrorCodes.DOWNSTREAM_AUTH_FAILED, { reason });
+    }
+}
+exports.DownstreamAuthFailedError = DownstreamAuthFailedError;
+class NoPendingConnectionFlowsError extends AuthorizationDomainError {
+    constructor() {
+        super('No pending connection flows found.', exports.AuthorizationErrorCodes.NO_PENDING_CONNECTION_FLOWS);
+    }
+}
+exports.NoPendingConnectionFlowsError = NoPendingConnectionFlowsError;
+class ConnectionFlowNotFoundError extends AuthorizationDomainError {
+    constructor(state) {
+        super('Connection flow not found.', exports.AuthorizationErrorCodes.CONNECTION_FLOW_NOT_FOUND, { state });
+    }
+}
+exports.ConnectionFlowNotFoundError = ConnectionFlowNotFoundError;
+class TokenExchangeFailedError extends AuthorizationDomainError {
+    constructor(reason) {
+        super(`Token exchange failed: ${reason}`, exports.AuthorizationErrorCodes.TOKEN_EXCHANGE_FAILED, { reason });
+    }
+}
+exports.TokenExchangeFailedError = TokenExchangeFailedError;
+class McpServerNotFoundError extends AuthorizationDomainError {
+    constructor(serverIdentifier) {
+        super('MCP server not found.', exports.AuthorizationErrorCodes.SERVER_NOT_FOUND, {
+            serverIdentifier,
+        });
+    }
+}
+exports.McpServerNotFoundError = McpServerNotFoundError;
+class McpClientNotFoundError extends AuthorizationDomainError {
+    constructor(clientId) {
+        super('Client not found.', exports.AuthorizationErrorCodes.CLIENT_NOT_FOUND, {
+            clientId,
+        });
+    }
+}
+exports.McpClientNotFoundError = McpClientNotFoundError;
+class InvalidRedirectUriError extends AuthorizationDomainError {
+    constructor(redirectUri, clientId) {
+        super('Redirect URI is not registered for this client.', exports.AuthorizationErrorCodes.INVALID_REDIRECT_URI, { redirectUri, clientId });
+    }
+}
+exports.InvalidRedirectUriError = InvalidRedirectUriError;
+//# sourceMappingURL=authorization.errors.js.map

package/dist/authorization-server/errors/authorization.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.errors.js","sourceRoot":"","sources":["../../../src/authorization-server/errors/authorization.errors.ts"],"names":[],"mappings":"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"}

package/dist/authorization-server/errors/client-registration.errors.d.ts

@@ -0,0 +1,30 @@
+export declare const ClientRegistrationErrorCodes: {
+    readonly CLIENT_ALREADY_REGISTERED: "CLIENT_ALREADY_REGISTERED";
+    readonly CLIENT_NOT_FOUND: "CLIENT_NOT_FOUND";
+    readonly INVALID_REDIRECT_URI: "INVALID_REDIRECT_URI";
+    readonly INVALID_GRANT_TYPE: "INVALID_GRANT_TYPE";
+    readonly INVALID_TOKEN_ENDPOINT_AUTH_METHOD: "INVALID_TOKEN_ENDPOINT_AUTH_METHOD";
+    readonly MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD";
+};
+type ClientRegistrationErrorCode = (typeof ClientRegistrationErrorCodes)[keyof typeof ClientRegistrationErrorCodes];
+export declare abstract class ClientRegistrationDomainError extends Error {
+    readonly code: ClientRegistrationErrorCode;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: ClientRegistrationErrorCode, context?: Record<string, unknown> | undefined);
+}
+export declare class ClientNotFoundError extends ClientRegistrationDomainError {
+    constructor(clientId: string);
+}
+export declare class InvalidRedirectUriError extends ClientRegistrationDomainError {
+    constructor(reason: string);
+}
+export declare class InvalidGrantTypeError extends ClientRegistrationDomainError {
+    constructor(reason: string);
+}
+export declare class InvalidTokenEndpointAuthMethodError extends ClientRegistrationDomainError {
+    constructor(method: string);
+}
+export declare class MissingRequiredFieldError extends ClientRegistrationDomainError {
+    constructor(fieldName: string);
+}
+export {};

package/dist/authorization-server/errors/client-registration.errors.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRequiredFieldError = exports.InvalidTokenEndpointAuthMethodError = exports.InvalidGrantTypeError = exports.InvalidRedirectUriError = exports.ClientNotFoundError = exports.ClientRegistrationDomainError = exports.ClientRegistrationErrorCodes = void 0;
+const errors_1 = require("@taico/errors");
+exports.ClientRegistrationErrorCodes = {
+    CLIENT_ALREADY_REGISTERED: errors_1.ErrorCodes.CLIENT_ALREADY_REGISTERED,
+    CLIENT_NOT_FOUND: errors_1.ErrorCodes.CLIENT_NOT_FOUND,
+    INVALID_REDIRECT_URI: errors_1.ErrorCodes.INVALID_REDIRECT_URI,
+    INVALID_GRANT_TYPE: errors_1.ErrorCodes.INVALID_GRANT_TYPE,
+    INVALID_TOKEN_ENDPOINT_AUTH_METHOD: errors_1.ErrorCodes.INVALID_TOKEN_ENDPOINT_AUTH_METHOD,
+    MISSING_REQUIRED_FIELD: errors_1.ErrorCodes.MISSING_REQUIRED_FIELD,
+};
+class ClientRegistrationDomainError extends Error {
+    code;
+    context;
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = this.constructor.name;
+    }
+}
+exports.ClientRegistrationDomainError = ClientRegistrationDomainError;
+class ClientNotFoundError extends ClientRegistrationDomainError {
+    constructor(clientId) {
+        super('Client not found.', exports.ClientRegistrationErrorCodes.CLIENT_NOT_FOUND, {
+            clientId,
+        });
+    }
+}
+exports.ClientNotFoundError = ClientNotFoundError;
+class InvalidRedirectUriError extends ClientRegistrationDomainError {
+    constructor(reason) {
+        super(`Invalid redirect URI: ${reason}`, exports.ClientRegistrationErrorCodes.INVALID_REDIRECT_URI, { reason });
+    }
+}
+exports.InvalidRedirectUriError = InvalidRedirectUriError;
+class InvalidGrantTypeError extends ClientRegistrationDomainError {
+    constructor(reason) {
+        super(`Invalid grant type configuration: ${reason}`, exports.ClientRegistrationErrorCodes.INVALID_GRANT_TYPE, { reason });
+    }
+}
+exports.InvalidGrantTypeError = InvalidGrantTypeError;
+class InvalidTokenEndpointAuthMethodError extends ClientRegistrationDomainError {
+    constructor(method) {
+        super(`Invalid token endpoint authentication method: ${method}`, exports.ClientRegistrationErrorCodes.INVALID_TOKEN_ENDPOINT_AUTH_METHOD, { method });
+    }
+}
+exports.InvalidTokenEndpointAuthMethodError = InvalidTokenEndpointAuthMethodError;
+class MissingRequiredFieldError extends ClientRegistrationDomainError {
+    constructor(fieldName) {
+        super(`Missing required field: ${fieldName}`, exports.ClientRegistrationErrorCodes.MISSING_REQUIRED_FIELD, { fieldName });
+    }
+}
+exports.MissingRequiredFieldError = MissingRequiredFieldError;
+//# sourceMappingURL=client-registration.errors.js.map

package/dist/authorization-server/errors/client-registration.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-registration.errors.js","sourceRoot":"","sources":["../../../src/authorization-server/errors/client-registration.errors.ts"],"names":[],"mappings":";;;AAAA,0CAA2C;AAG9B,QAAA,4BAA4B,GAAG;IAC1C,yBAAyB,EAAE,mBAAU,CAAC,yBAAyB;IAC/D,gBAAgB,EAAE,mBAAU,CAAC,gBAAgB;IAC7C,oBAAoB,EAAE,mBAAU,CAAC,oBAAoB;IACrD,kBAAkB,EAAE,mBAAU,CAAC,kBAAkB;IACjD,kCAAkC,EAChC,mBAAU,CAAC,kCAAkC;IAC/C,sBAAsB,EAAE,mBAAU,CAAC,sBAAsB;CACjD,CAAC;AASX,MAAsB,6BAA8B,SAAQ,KAAK;IAGpD;IACA;IAHX,YACE,OAAe,EACN,IAAiC,EACjC,OAAiC;QAE1C,KAAK,CAAC,OAAO,CAAC,CAAC;QAHN,SAAI,GAAJ,IAAI,CAA6B;QACjC,YAAO,GAAP,OAAO,CAA0B;QAG1C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACpC,CAAC;CACF;AATD,sEASC;AAED,MAAa,mBAAoB,SAAQ,6BAA6B;IACpE,YAAY,QAAgB;QAC1B,KAAK,CAAC,mBAAmB,EAAE,oCAA4B,CAAC,gBAAgB,EAAE;YACxE,QAAQ;SACT,CAAC,CAAC;IACL,CAAC;CACF;AAND,kDAMC;AAED,MAAa,uBAAwB,SAAQ,6BAA6B;IACxE,YAAY,MAAc;QACxB,KAAK,CACH,yBAAyB,MAAM,EAAE,EACjC,oCAA4B,CAAC,oBAAoB,EACjD,EAAE,MAAM,EAAE,CACX,CAAC;IACJ,CAAC;CACF;AARD,0DAQC;AAED,MAAa,qBAAsB,SAAQ,6BAA6B;IACtE,YAAY,MAAc;QACxB,KAAK,CACH,qCAAqC,MAAM,EAAE,EAC7C,oCAA4B,CAAC,kBAAkB,EAC/C,EAAE,MAAM,EAAE,CACX,CAAC;IACJ,CAAC;CACF;AARD,sDAQC;AAED,MAAa,mCAAoC,SAAQ,6BAA6B;IACpF,YAAY,MAAc;QACxB,KAAK,CACH,iDAAiD,MAAM,EAAE,EACzD,oCAA4B,CAAC,kCAAkC,EAC/D,EAAE,MAAM,EAAE,CACX,CAAC;IACJ,CAAC;CACF;AARD,kFAQC;AAED,MAAa,yBAA0B,SAAQ,6BAA6B;IAC1E,YAAY,SAAiB;QAC3B,KAAK,CACH,2BAA2B,SAAS,EAAE,EACtC,oCAA4B,CAAC,sBAAsB,EACnD,EAAE,SAAS,EAAE,CACd,CAAC;IACJ,CAAC;CACF;AARD,8DAQC"}

package/dist/authorization-server/errors/token.errors.d.ts

@@ -0,0 +1,57 @@
+export declare const TokenErrorCodes: {
+    readonly INVALID_GRANT_TYPE: "INVALID_GRANT_TYPE";
+    readonly MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD";
+    readonly INVALID_AUTHORIZATION_CODE: "INVALID_AUTHORIZATION_CODE";
+    readonly CLIENT_ID_MISMATCH: "CLIENT_ID_MISMATCH";
+    readonly AUTHORIZATION_CODE_USED: "AUTHORIZATION_CODE_USED";
+    readonly AUTHORIZATION_CODE_EXPIRED: "AUTHORIZATION_CODE_EXPIRED";
+    readonly REDIRECT_URI_MISMATCH: "REDIRECT_URI_MISMATCH";
+    readonly MISSING_PKCE_PARAMETERS: "MISSING_PKCE_PARAMETERS";
+    readonly INVALID_CODE_VERIFIER: "INVALID_CODE_VERIFIER";
+    readonly INVALID_REFRESH_TOKEN: "INVALID_REFRESH_TOKEN";
+    readonly REFRESH_TOKEN_EXPIRED: "REFRESH_TOKEN_EXPIRED";
+    readonly REFRESH_TOKEN_REVOKED: "REFRESH_TOKEN_REVOKED";
+};
+type TokenErrorCode = (typeof TokenErrorCodes)[keyof typeof TokenErrorCodes];
+export declare abstract class TokenDomainError extends Error {
+    readonly code: TokenErrorCode;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: TokenErrorCode, context?: Record<string, unknown> | undefined);
+}
+export declare class InvalidGrantTypeError extends TokenDomainError {
+    constructor(grantType: string);
+}
+export declare class MissingRequiredParametersError extends TokenDomainError {
+    constructor(grantType: string);
+}
+export declare class InvalidAuthorizationCodeError extends TokenDomainError {
+    constructor(code: string);
+}
+export declare class ClientIdMismatchError extends TokenDomainError {
+    constructor();
+}
+export declare class AuthorizationCodeUsedError extends TokenDomainError {
+    constructor();
+}
+export declare class AuthorizationCodeExpiredError extends TokenDomainError {
+    constructor();
+}
+export declare class RedirectUriMismatchError extends TokenDomainError {
+    constructor();
+}
+export declare class MissingPkceParametersError extends TokenDomainError {
+    constructor();
+}
+export declare class InvalidCodeVerifierError extends TokenDomainError {
+    constructor();
+}
+export declare class InvalidRefreshTokenError extends TokenDomainError {
+    constructor();
+}
+export declare class RefreshTokenExpiredError extends TokenDomainError {
+    constructor();
+}
+export declare class RefreshTokenRevokedError extends TokenDomainError {
+    constructor();
+}
+export {};

package/dist/authorization-server/errors/token.errors.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshTokenRevokedError = exports.RefreshTokenExpiredError = exports.InvalidRefreshTokenError = exports.InvalidCodeVerifierError = exports.MissingPkceParametersError = exports.RedirectUriMismatchError = exports.AuthorizationCodeExpiredError = exports.AuthorizationCodeUsedError = exports.ClientIdMismatchError = exports.InvalidAuthorizationCodeError = exports.MissingRequiredParametersError = exports.InvalidGrantTypeError = exports.TokenDomainError = exports.TokenErrorCodes = void 0;
+const errors_1 = require("@taico/errors");
+exports.TokenErrorCodes = {
+    INVALID_GRANT_TYPE: errors_1.ErrorCodes.INVALID_GRANT_TYPE,
+    MISSING_REQUIRED_FIELD: errors_1.ErrorCodes.MISSING_REQUIRED_FIELD,
+    INVALID_AUTHORIZATION_CODE: errors_1.ErrorCodes.INVALID_AUTHORIZATION_CODE,
+    CLIENT_ID_MISMATCH: errors_1.ErrorCodes.CLIENT_ID_MISMATCH,
+    AUTHORIZATION_CODE_USED: errors_1.ErrorCodes.AUTHORIZATION_CODE_USED,
+    AUTHORIZATION_CODE_EXPIRED: errors_1.ErrorCodes.AUTHORIZATION_CODE_EXPIRED,
+    REDIRECT_URI_MISMATCH: errors_1.ErrorCodes.REDIRECT_URI_MISMATCH,
+    MISSING_PKCE_PARAMETERS: errors_1.ErrorCodes.MISSING_PKCE_PARAMETERS,
+    INVALID_CODE_VERIFIER: errors_1.ErrorCodes.INVALID_CODE_VERIFIER,
+    INVALID_REFRESH_TOKEN: errors_1.ErrorCodes.INVALID_REFRESH_TOKEN,
+    REFRESH_TOKEN_EXPIRED: errors_1.ErrorCodes.REFRESH_TOKEN_EXPIRED,
+    REFRESH_TOKEN_REVOKED: errors_1.ErrorCodes.REFRESH_TOKEN_REVOKED,
+};
+class TokenDomainError extends Error {
+    code;
+    context;
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = this.constructor.name;
+    }
+}
+exports.TokenDomainError = TokenDomainError;
+class InvalidGrantTypeError extends TokenDomainError {
+    constructor(grantType) {
+        super('Invalid grant_type.', exports.TokenErrorCodes.INVALID_GRANT_TYPE, {
+            grantType,
+        });
+    }
+}
+exports.InvalidGrantTypeError = InvalidGrantTypeError;
+class MissingRequiredParametersError extends TokenDomainError {
+    constructor(grantType) {
+        super(`Missing required parameters for ${grantType} grant.`, exports.TokenErrorCodes.MISSING_REQUIRED_FIELD, { grantType });
+    }
+}
+exports.MissingRequiredParametersError = MissingRequiredParametersError;
+class InvalidAuthorizationCodeError extends TokenDomainError {
+    constructor(code) {
+        super('Invalid authorization code.', exports.TokenErrorCodes.INVALID_AUTHORIZATION_CODE, { code });
+    }
+}
+exports.InvalidAuthorizationCodeError = InvalidAuthorizationCodeError;
+class ClientIdMismatchError extends TokenDomainError {
+    constructor() {
+        super('Client ID mismatch.', exports.TokenErrorCodes.CLIENT_ID_MISMATCH);
+    }
+}
+exports.ClientIdMismatchError = ClientIdMismatchError;
+class AuthorizationCodeUsedError extends TokenDomainError {
+    constructor() {
+        super('Authorization code has already been used.', exports.TokenErrorCodes.AUTHORIZATION_CODE_USED);
+    }
+}
+exports.AuthorizationCodeUsedError = AuthorizationCodeUsedError;
+class AuthorizationCodeExpiredError extends TokenDomainError {
+    constructor() {
+        super('Authorization code has expired.', exports.TokenErrorCodes.AUTHORIZATION_CODE_EXPIRED);
+    }
+}
+exports.AuthorizationCodeExpiredError = AuthorizationCodeExpiredError;
+class RedirectUriMismatchError extends TokenDomainError {
+    constructor() {
+        super('Redirect URI mismatch.', exports.TokenErrorCodes.REDIRECT_URI_MISMATCH);
+    }
+}
+exports.RedirectUriMismatchError = RedirectUriMismatchError;
+class MissingPkceParametersError extends TokenDomainError {
+    constructor() {
+        super('Missing PKCE parameters.', exports.TokenErrorCodes.MISSING_PKCE_PARAMETERS);
+    }
+}
+exports.MissingPkceParametersError = MissingPkceParametersError;
+class InvalidCodeVerifierError extends TokenDomainError {
+    constructor() {
+        super('Invalid code_verifier.', exports.TokenErrorCodes.INVALID_CODE_VERIFIER);
+    }
+}
+exports.InvalidCodeVerifierError = InvalidCodeVerifierError;
+class InvalidRefreshTokenError extends TokenDomainError {
+    constructor() {
+        super('Invalid refresh token.', exports.TokenErrorCodes.INVALID_REFRESH_TOKEN);
+    }
+}
+exports.InvalidRefreshTokenError = InvalidRefreshTokenError;
+class RefreshTokenExpiredError extends TokenDomainError {
+    constructor() {
+        super('Refresh token has expired.', exports.TokenErrorCodes.REFRESH_TOKEN_EXPIRED);
+    }
+}
+exports.RefreshTokenExpiredError = RefreshTokenExpiredError;
+class RefreshTokenRevokedError extends TokenDomainError {
+    constructor() {
+        super('Refresh token has been revoked.', exports.TokenErrorCodes.REFRESH_TOKEN_REVOKED);
+    }
+}
+exports.RefreshTokenRevokedError = RefreshTokenRevokedError;
+//# sourceMappingURL=token.errors.js.map

package/dist/authorization-server/errors/token.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.errors.js","sourceRoot":"","sources":["../../../src/authorization-server/errors/token.errors.ts"],"names":[],"mappings":"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"}

package/dist/authorization-server/issued-access-token.service.d.ts

@@ -0,0 +1,28 @@
+import { Repository } from 'typeorm';
+import { IssuedAccessTokenEntity } from './entities/issued-access-token.entity';
+import { TokenSignerService } from '../auth/crypto/token-signer.service';
+import { ActorEntity } from '../identity-provider/actor.entity';
+export interface IssueTokenInput {
+    subjectActor: ActorEntity;
+    issuedByActor: ActorEntity;
+    name: string;
+    scopes: string[];
+    expirationDays?: number;
+}
+export interface IssueTokenResult {
+    entity: IssuedAccessTokenEntity;
+    token: string;
+}
+export declare class IssuedAccessTokenService {
+    private readonly tokenRepository;
+    private readonly tokenSignerService;
+    private readonly logger;
+    constructor(tokenRepository: Repository<IssuedAccessTokenEntity>, tokenSignerService: TokenSignerService);
+    issueToken(input: IssueTokenInput): Promise<IssueTokenResult>;
+    listTokensForSubject(subjectActorId: string): Promise<IssuedAccessTokenEntity[]>;
+    getTokenById(tokenId: string): Promise<IssuedAccessTokenEntity | null>;
+    revokeTokenById(tokenId: string): Promise<IssuedAccessTokenEntity | null>;
+    revokeTokenByJti(jti: string): Promise<IssuedAccessTokenEntity | null>;
+    isTokenRevoked(jti: string): Promise<boolean>;
+    updateLastUsed(jti: string): Promise<void>;
+}