@medusajs/api-key 0.1.0 → 0.1.1-next-20240319121007

package/dist/joiner-config.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.joinerConfig = exports.entityNameToLinkableKeysMap = exports.LinkableKeys = void 0;
 const modules_sdk_1 = require("@medusajs/modules-sdk");
-// TODO manage the config
+const api_key_1 = __importDefault(require("./models/api-key"));
 exports.LinkableKeys = {};
 const entityLinkableKeysMap = {};
 Object.entries(exports.LinkableKeys).forEach(([key, value]) => {
@@ -17,5 +20,10 @@ exports.joinerConfig = {
     serviceName: modules_sdk_1.Modules.API_KEY,
     primaryKeys: ["id"],
     linkableKeys: exports.LinkableKeys,
-    alias: [],
+    alias: [
+        {
+            name: ["api_key", "api_keys"],
+            args: { entity: api_key_1.default.name },
+        },
+    ],
 };

package/dist/migrations/InitialSetup20240221144943.d.ts

@@ -0,0 +1,4 @@
+import { Migration } from "@mikro-orm/migrations";
+export declare class InitialSetup20240221144943 extends Migration {
+    up(): Promise<void>;
+}

package/dist/migrations/InitialSetup20240221144943.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitialSetup20240221144943 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class InitialSetup20240221144943 extends migrations_1.Migration {
+    async up() {
+        this.addSql('create table if not exists "api_key" ("id" text not null, "token" text not null, "salt" text not null, "redacted" text not null, "title" text not null, "type" text not null, "last_used_at" timestamptz null, "created_by" text not null, "created_at" timestamptz not null default now(), "revoked_by" text null, "revoked_at" timestamptz null, constraint "api_key_pkey" primary key ("id"));');
+        this.addSql('CREATE UNIQUE INDEX IF NOT EXISTS "IDX_api_key_token_unique" ON "api_key" (token);');
+        this.addSql('CREATE INDEX IF NOT EXISTS "IDX_api_key_type" ON "api_key" (type);');
+    }
+}
+exports.InitialSetup20240221144943 = InitialSetup20240221144943;

package/dist/models/api-key.d.ts

@@ -1,7 +1,15 @@
 export default class ApiKey {
     id: string;
+    token: string;
+    salt: string;
+    redacted: string;
+    title: string;
+    type: "publishable" | "secret";
+    last_used_at: Date | null;
+    created_by: string;
     created_at: Date;
-    updated_at: Date;
+    revoked_by: string | null;
+    revoked_at: Date | null;
     onCreate(): void;
     onInit(): void;
 }

package/dist/models/api-key.js

@@ -11,8 +11,21 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const core_1 = require("@mikro-orm/core");
-// TODO:
+const TypeIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: "api_key",
+    columns: "type",
+});
+const TokenIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: "api_key",
+    columns: "token",
+    unique: true,
+});
 let ApiKey = class ApiKey {
+    constructor() {
+        this.last_used_at = null;
+        this.revoked_by = null;
+        this.revoked_at = null;
+    }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "apk");
     }
@@ -24,6 +37,40 @@ __decorate([
     (0, core_1.PrimaryKey)({ columnType: "text" }),
     __metadata("design:type", String)
 ], ApiKey.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    TokenIndex.MikroORMIndex(),
+    __metadata("design:type", String)
+], ApiKey.prototype, "token", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ApiKey.prototype, "salt", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ApiKey.prototype, "redacted", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ApiKey.prototype, "title", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    (0, core_1.Enum)({ items: ["publishable", "secret"] }),
+    TypeIndex.MikroORMIndex(),
+    __metadata("design:type", String)
+], ApiKey.prototype, "type", void 0);
+__decorate([
+    (0, core_1.Property)({
+        columnType: "timestamptz",
+        nullable: true,
+    }),
+    __metadata("design:type", Object)
+], ApiKey.prototype, "last_used_at", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ApiKey.prototype, "created_by", void 0);
 __decorate([
     (0, core_1.Property)({
         onCreate: () => new Date(),
@@ -32,15 +79,17 @@ __decorate([
     }),
     __metadata("design:type", Date)
 ], ApiKey.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], ApiKey.prototype, "revoked_by", void 0);
 __decorate([
     (0, core_1.Property)({
-        onCreate: () => new Date(),
-        onUpdate: () => new Date(),
         columnType: "timestamptz",
-        defaultRaw: "now()",
+        nullable: true,
     }),
-    __metadata("design:type", Date)
-], ApiKey.prototype, "updated_at", void 0);
+    __metadata("design:type", Object)
+], ApiKey.prototype, "revoked_at", void 0);
 __decorate([
     (0, core_1.BeforeCreate)(),
     __metadata("design:type", Function),

package/dist/services/api-key-module-service.d.ts

@@ -1,6 +1,7 @@
-import { Context, DAL, ApiKeyTypes, IApiKeyModuleService, ModulesSdkTypes, InternalModuleDeclaration, ModuleJoinerConfig } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
+import { Context, DAL, ApiKeyTypes, IApiKeyModuleService, ModulesSdkTypes, InternalModuleDeclaration, ModuleJoinerConfig, FindConfig, FilterableApiKeyProps } from "@medusajs/types";
 import { ApiKey } from "../models";
+import { RevokeApiKeyInput, TokenDTO, UpdateApiKeyInput } from "../types";
+import { ModulesSdkUtils } from "@medusajs/utils";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     apiKeyService: ModulesSdkTypes.InternalModuleService<any>;
@@ -18,11 +19,25 @@ export default class ApiKeyModuleService<TEntity extends ApiKey = ApiKey> extend
     __joinerConfig(): ModuleJoinerConfig;
     create(data: ApiKeyTypes.CreateApiKeyDTO[], sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO[]>;
     create(data: ApiKeyTypes.CreateApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO>;
-    protected create_(data: ApiKeyTypes.CreateApiKeyDTO | ApiKeyTypes.CreateApiKeyDTO[], sharedContext?: Context): Promise<TEntity | TEntity[]>;
-    update(data: ApiKeyTypes.UpdateApiKeyDTO[], sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO[]>;
-    update(data: ApiKeyTypes.UpdateApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO>;
-    protected update_(data: ApiKeyTypes.UpdateApiKeyDTO[] | ApiKeyTypes.UpdateApiKeyDTO, sharedContext?: Context): Promise<TEntity[] | TEntity>;
-    revoke(id: string, sharedContext?: Context): Promise<void>;
-    authenticate(id: string, sharedContext?: Context): Promise<boolean>;
+    protected create_(data: ApiKeyTypes.CreateApiKeyDTO[], sharedContext?: Context): Promise<[TEntity[], TokenDTO[]]>;
+    upsert(data: ApiKeyTypes.UpsertApiKeyDTO[], sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO[]>;
+    upsert(data: ApiKeyTypes.UpsertApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO>;
+    update(id: string, data: ApiKeyTypes.UpdateApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO>;
+    update(selector: FilterableApiKeyProps, data: ApiKeyTypes.UpdateApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO[]>;
+    protected update_(normalizedInput: UpdateApiKeyInput[], sharedContext?: Context): Promise<TEntity[]>;
+    retrieve(id: string, config?: FindConfig<ApiKeyTypes.ApiKeyDTO>, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO>;
+    list(filters?: ApiKeyTypes.FilterableApiKeyProps, config?: FindConfig<ApiKeyTypes.ApiKeyDTO>, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO[]>;
+    listAndCount(filters?: ApiKeyTypes.FilterableApiKeyProps, config?: FindConfig<ApiKeyTypes.ApiKeyDTO>, sharedContext?: Context): Promise<[ApiKeyTypes.ApiKeyDTO[], number]>;
+    revoke(id: string, data: ApiKeyTypes.RevokeApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO>;
+    revoke(selector: FilterableApiKeyProps, data: ApiKeyTypes.RevokeApiKeyDTO, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO[]>;
+    revoke_(normalizedInput: RevokeApiKeyInput[], sharedContext?: Context): Promise<TEntity[]>;
+    authenticate(token: string, sharedContext?: Context): Promise<ApiKeyTypes.ApiKeyDTO | false>;
+    protected authenticate_(token: string, sharedContext?: Context): Promise<ApiKey | false>;
+    protected validateCreateApiKeys_(data: ApiKeyTypes.CreateApiKeyDTO[], sharedContext?: Context): Promise<void>;
+    protected normalizeUpdateInput_<T>(idOrSelector: string | FilterableApiKeyProps, data: Omit<T, "id">, sharedContext?: Context): Promise<T[]>;
+    protected validateRevokeApiKeys_(data: RevokeApiKeyInput[], sharedContext?: Context): Promise<void>;
+    protected static generatePublishableKey(): TokenDTO;
+    protected static generateSecretKey(): Promise<TokenDTO>;
+    protected static calculateHash(token: string, salt: string): Promise<string>;
 }
 export {};

package/dist/services/api-key-module-service.js

@@ -11,10 +11,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@medusajs/utils");
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = __importDefault(require("util"));
+const types_1 = require("@medusajs/types");
 const joiner_config_1 = require("../joiner-config");
 const _models_1 = require("../models");
+const utils_1 = require("@medusajs/utils");
+const scrypt = util_1.default.promisify(crypto_1.default.scrypt);
 const generateMethodForModels = [];
 class ApiKeyModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.ApiKey, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
     constructor({ baseRepository, apiKeyService }, moduleDeclaration) {
@@ -28,30 +35,244 @@ class ApiKeyModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceF
         return joiner_config_1.joinerConfig;
     }
     async create(data, sharedContext = {}) {
-        const createdApiKeys = await this.create_(data, sharedContext);
-        return await this.baseRepository_.serialize(createdApiKeys, {
+        const [createdApiKeys, generatedTokens] = await this.create_(Array.isArray(data) ? data : [data], sharedContext);
+        const serializedResponse = await this.baseRepository_.serialize(createdApiKeys, {
             populate: true,
         });
+        // When creating we want to return the raw token, as this will be the only time the user will be able to take note of it for future use.
+        const responseWithRawToken = serializedResponse.map((key) => ({
+            ...key,
+            token: generatedTokens.find((t) => t.hashedToken === key.token)?.rawToken ??
+                key.token,
+            salt: undefined,
+        }));
+        return Array.isArray(data) ? responseWithRawToken : responseWithRawToken[0];
     }
     async create_(data, sharedContext = {}) {
-        const data_ = Array.isArray(data) ? data : [data];
-        const createdApiKeys = await this.apiKeyService_.create(data_, sharedContext);
-        return Array.isArray(data) ? createdApiKeys : createdApiKeys[0];
+        await this.validateCreateApiKeys_(data, sharedContext);
+        const normalizedInput = [];
+        const generatedTokens = [];
+        for (const key of data) {
+            let tokenData;
+            if (key.type === utils_1.ApiKeyType.PUBLISHABLE) {
+                tokenData = ApiKeyModuleService.generatePublishableKey();
+            }
+            else {
+                tokenData = await ApiKeyModuleService.generateSecretKey();
+            }
+            generatedTokens.push(tokenData);
+            normalizedInput.push({
+                ...key,
+                token: tokenData.hashedToken,
+                salt: tokenData.salt,
+                redacted: tokenData.redacted,
+            });
+        }
+        const createdApiKeys = await this.apiKeyService_.create(normalizedInput, sharedContext);
+        return [createdApiKeys, generatedTokens];
+    }
+    async upsert(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((apiKey) => !!apiKey.id);
+        const forCreate = input.filter((apiKey) => !apiKey.id);
+        const operations = [];
+        if (forCreate.length) {
+            const op = async () => {
+                const [createdApiKeys, generatedTokens] = await this.create_(forCreate, sharedContext);
+                const serializedResponse = await this.baseRepository_.serialize(createdApiKeys, {
+                    populate: true,
+                });
+                return serializedResponse.map((key) => ({
+                    ...key,
+                    token: generatedTokens.find((t) => t.hashedToken === key.token)
+                        ?.rawToken ?? key.token,
+                    salt: undefined,
+                }));
+            };
+            operations.push(op());
+        }
+        if (forUpdate.length) {
+            const op = async () => {
+                const updateResp = await this.update_(forUpdate, sharedContext);
+                return await this.baseRepository_.serialize(updateResp);
+            };
+            operations.push(op());
+        }
+        const result = (await (0, utils_1.promiseAll)(operations)).flat();
+        return Array.isArray(data) ? result : result[0];
     }
-    async update(data, sharedContext = {}) {
-        const updatedApiKeys = await this.update_(data, sharedContext);
-        return await this.baseRepository_.serialize(updatedApiKeys, {
+    async update(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = await this.normalizeUpdateInput_(idOrSelector, data, sharedContext);
+        const updatedApiKeys = await this.update_(normalizedInput, sharedContext);
+        const serializedResponse = await this.baseRepository_.serialize(updatedApiKeys.map(omitToken), {
             populate: true,
         });
+        return (0, utils_1.isString)(idOrSelector) ? serializedResponse[0] : serializedResponse;
     }
-    async update_(data, sharedContext = {}) {
-        return [];
+    async update_(normalizedInput, sharedContext = {}) {
+        const updateRequest = normalizedInput.map((k) => ({
+            id: k.id,
+            title: k.title,
+        }));
+        const updatedApiKeys = await this.apiKeyService_.update(updateRequest, sharedContext);
+        return updatedApiKeys;
     }
-    async revoke(id, sharedContext = {}) {
-        return;
+    async retrieve(id, config, sharedContext) {
+        const apiKey = await this.apiKeyService_.retrieve(id, config, sharedContext);
+        return await this.baseRepository_.serialize(omitToken(apiKey), {
+            populate: true,
+        });
     }
-    authenticate(id, sharedContext = {}) {
-        return Promise.resolve(false);
+    async list(filters, config, sharedContext) {
+        const apiKeys = await this.apiKeyService_.list(filters, config, sharedContext);
+        return await this.baseRepository_.serialize(apiKeys.map(omitToken), {
+            populate: true,
+        });
+    }
+    async listAndCount(filters, config, sharedContext) {
+        const [apiKeys, count] = await this.apiKeyService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(apiKeys.map(omitToken), {
+                populate: true,
+            }),
+            count,
+        ];
+    }
+    async revoke(idOrSelector, data, sharedContext = {}) {
+        const normalizedInput = await this.normalizeUpdateInput_(idOrSelector, data, sharedContext);
+        const revokedApiKeys = await this.revoke_(normalizedInput, sharedContext);
+        const serializedResponse = await this.baseRepository_.serialize(revokedApiKeys.map(omitToken), {
+            populate: true,
+        });
+        return (0, utils_1.isString)(idOrSelector) ? serializedResponse[0] : serializedResponse;
+    }
+    async revoke_(normalizedInput, sharedContext = {}) {
+        await this.validateRevokeApiKeys_(normalizedInput);
+        const updateRequest = normalizedInput.map((k) => {
+            const revokedAt = new Date();
+            if (k.revoke_in && k.revoke_in > 0) {
+                revokedAt.setSeconds(revokedAt.getSeconds() + k.revoke_in);
+            }
+            return {
+                id: k.id,
+                revoked_at: revokedAt,
+                revoked_by: k.revoked_by,
+            };
+        });
+        const revokedApiKeys = await this.apiKeyService_.update(updateRequest, sharedContext);
+        return revokedApiKeys;
+    }
+    async authenticate(token, sharedContext = {}) {
+        const result = await this.authenticate_(token, sharedContext);
+        if (!result) {
+            return false;
+        }
+        const serialized = await this.baseRepository_.serialize(result, {
+            populate: true,
+        });
+        return serialized;
+    }
+    async authenticate_(token, sharedContext = {}) {
+        // Since we only allow up to 2 active tokens, getitng the list and checking each token isn't an issue.
+        // We can always filter on the redacted key if we add support for an arbitrary number of tokens.
+        const secretKeys = await this.apiKeyService_.list({
+            type: utils_1.ApiKeyType.SECRET,
+            // If the revoke date is set in the future, it means the key is still valid.
+            $or: [
+                { revoked_at: { $eq: null } },
+                { revoked_at: { $gt: new Date() } },
+            ],
+        }, { take: null }, sharedContext);
+        const matches = await (0, utils_1.promiseAll)(secretKeys.map(async (dbKey) => {
+            const hashedInput = await ApiKeyModuleService.calculateHash(token, dbKey.salt);
+            if (hashedInput === dbKey.token) {
+                return dbKey;
+            }
+            return undefined;
+        }));
+        const matchedKeys = matches.filter((match) => !!match);
+        if (!matchedKeys.length) {
+            return false;
+        }
+        return matchedKeys[0];
+    }
+    async validateCreateApiKeys_(data, sharedContext = {}) {
+        if (!data.length) {
+            return;
+        }
+        // There can only be 2 secret keys at most, and one has to be with a revoked_at date set, so only 1 can be newly created.
+        const secretKeysToCreate = data.filter((k) => k.type === utils_1.ApiKeyType.SECRET);
+        if (secretKeysToCreate.length > 1) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `You can only create one secret key at a time. You tried to create ${secretKeysToCreate.length} secret keys.`);
+        }
+        // There already is a key that is not set to expire/or it hasn't expired
+        const dbSecretKeys = await this.apiKeyService_.list({
+            type: utils_1.ApiKeyType.SECRET,
+            $or: [
+                { revoked_at: { $eq: null } },
+                { revoked_at: { $gt: new Date() } },
+            ],
+        }, { take: null }, sharedContext);
+        if (dbSecretKeys.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `You can only have one active secret key a time. Revoke or delete your existing key before creating a new one.`);
+        }
+    }
+    async normalizeUpdateInput_(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        if ((0, utils_1.isObject)(idOrSelector)) {
+            const apiKeys = await this.apiKeyService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = apiKeys.map((apiKey) => ({
+                id: apiKey.id,
+                ...data,
+            }));
+        }
+        return normalizedInput;
+    }
+    async validateRevokeApiKeys_(data, sharedContext = {}) {
+        if (!data.length) {
+            return;
+        }
+        if (data.some((k) => !k.id)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `You must provide an api key id field when revoking a key.`);
+        }
+        if (data.some((k) => !k.revoked_by)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `You must provide a revoked_by field when revoking a key.`);
+        }
+        const revokedApiKeys = await this.apiKeyService_.list({
+            id: data.map((k) => k.id),
+            type: utils_1.ApiKeyType.SECRET,
+            revoked_at: { $ne: null },
+        }, {}, sharedContext);
+        if (revokedApiKeys.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `There are ${revokedApiKeys.length} secret keys that are already revoked.`);
+        }
+    }
+    // These are public keys, so there is no point hashing them.
+    static generatePublishableKey() {
+        const token = "pk_" + crypto_1.default.randomBytes(32).toString("hex");
+        return {
+            rawToken: token,
+            hashedToken: token,
+            salt: "",
+            redacted: redactKey(token),
+        };
+    }
+    static async generateSecretKey() {
+        const token = "sk_" + crypto_1.default.randomBytes(32).toString("hex");
+        const salt = crypto_1.default.randomBytes(16).toString("hex");
+        const hashed = await this.calculateHash(token, salt);
+        return {
+            rawToken: token,
+            hashedToken: hashed,
+            salt,
+            redacted: redactKey(token),
+        };
+    }
+    static async calculateHash(token, salt) {
+        return (await scrypt(token, salt, 64)).toString("hex");
     }
 }
 exports.default = ApiKeyModuleService;
@@ -66,7 +287,7 @@ __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ApiKeyModuleService.prototype, "create_", null);
 __decorate([
@@ -75,25 +296,75 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
+], ApiKeyModuleService.prototype, "upsert", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
 ], ApiKeyModuleService.prototype, "update", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ApiKeyModuleService.prototype, "update_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ApiKeyModuleService.prototype, "retrieve", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ApiKeyModuleService.prototype, "list", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ApiKeyModuleService.prototype, "listAndCount", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ApiKeyModuleService.prototype, "revoke", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ApiKeyModuleService.prototype, "revoke_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
-], ApiKeyModuleService.prototype, "revoke", null);
+], ApiKeyModuleService.prototype, "authenticate", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
-], ApiKeyModuleService.prototype, "authenticate", null);
+], ApiKeyModuleService.prototype, "authenticate_", null);
+// We are mutating the object here as what microORM relies on non-enumerable fields for serialization, among other things.
+const omitToken = (
+// We have to make salt optional before deleting it (and we do want it required in the DB)
+key) => {
+    key.token = key.type === utils_1.ApiKeyType.SECRET ? "" : key.token;
+    delete key.salt;
+    return key;
+};
+const redactKey = (key) => {
+    return [key.slice(0, 6), key.slice(-3)].join("***");
+};

package/dist/types/index.d.ts

@@ -1,5 +1,26 @@
+import { ApiKeyType, RevokeApiKeyDTO, UpdateApiKeyDTO } from "@medusajs/types";
 import { IEventBusModuleService, Logger } from "@medusajs/types";
 export type InitializeModuleInjectableDependencies = {
     logger?: Logger;
     eventBusService?: IEventBusModuleService;
 };
+export type CreateApiKeyDTO = {
+    token: string;
+    salt: string;
+    redacted: string;
+    title: string;
+    type: ApiKeyType;
+    created_by: string;
+};
+export type TokenDTO = {
+    rawToken: string;
+    hashedToken: string;
+    salt: string;
+    redacted: string;
+};
+export type UpdateApiKeyInput = UpdateApiKeyDTO & {
+    id: string;
+};
+export type RevokeApiKeyInput = RevokeApiKeyDTO & {
+    id: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/api-key",
-  "version": "0.1.0",
+  "version": "0.1.1-next-20240319121007",
   "description": "Medusa API Key module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,7 +29,7 @@
     "prepublishOnly": "cross-env NODE_ENV=production tsc --build && tsc-alias -p tsconfig.json",
     "build": "rimraf dist && tsc --build && tsc-alias -p tsconfig.json",
     "test": "jest --runInBand --bail --forceExit -- src/**/__tests__/**/*.ts",
-    "test:integration": "jest --runInBand --forceExit -- integration-tests/**/__tests__/**/*.ts",
+    "test:integration": "jest --forceExit -- integration-tests/**/__tests__/**/*.ts",
     "migration:generate": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:generate",
     "migration:initial": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create --initial",
     "migration:create": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create",
@@ -40,7 +40,7 @@
     "@mikro-orm/cli": "5.9.7",
     "cross-env": "^5.2.1",
     "jest": "^29.6.3",
-    "medusa-test-utils": "^1.1.40",
+    "medusa-test-utils": "1.1.42-next-20240319121007",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
@@ -48,14 +48,14 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "^1.12.4",
-    "@medusajs/types": "^1.11.8",
-    "@medusajs/utils": "^1.11.1",
+    "@medusajs/modules-sdk": "1.12.9-next-20240319121007",
+    "@medusajs/types": "1.11.14-next-20240319121007",
+    "@medusajs/utils": "1.11.7-next-20240319121007",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",
     "awilix": "^8.0.0",
-    "dotenv": "^16.1.4",
+    "dotenv": "^16.4.5",
     "knex": "2.4.2"
   }
 }