@designbasekorea/figma-license-core 0.3.2 → 0.4.0

package/dist/index.js

@@ -54,6 +54,7 @@ function asText(input) {
 function inferCode(text) {
     const normalized = text.toLowerCase();
     if (normalized.includes('activation limit')
+        || normalized.includes('activation_limit_reached')
         || normalized.includes('seat')
         || normalized.includes('too many activations')
         || normalized.includes('already activated on maximum')) {
@@ -164,7 +165,7 @@ function validationMessage(result) {
             return '이 멤버십 라이선스는 철회되었습니다.';
         case 'expired':
         case 'license_expired':
-            return '멤버십 라이선스가 만료되었습니다. YouTube 커뮤니티에서 이번 달 키를 확인해 주세요.';
+            return '라이선스가 만료되었습니다. 새 키를 확인해 주세요.';
         case 'not_started':
             return '이 멤버십 라이선스는 아직 시작되지 않았습니다.';
         case 'rate_limited':
@@ -181,6 +182,8 @@ function validationMessage(result) {
 function validationErrorCode(result) {
     const status = (result.errorCode || result.licenseStatus || '').toLowerCase();
     switch (status) {
+        case 'activation_limit_reached':
+            return exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED;
         case 'expired':
         case 'license_expired':
             return exports.LicenseErrorCode.LICENSE_EXPIRED;
@@ -291,7 +294,7 @@ class LicenseCore {
     }
     async initialize() {
         let state = await this.getStatus();
-        if (state.paymentStatus === 'PAID' && state.licenseKey && state.licenseKey !== this.config.masterCode) {
+        if (state.licenseKey && state.licenseKey !== this.config.masterCode) {
             try {
                 const validateResult = this.deps.transport.validate
                     ? await this.deps.transport.validate({
@@ -432,10 +435,12 @@ class LicenseCore {
         }
         let verifyResult;
         try {
+            const current = await this.getStatus();
             verifyResult = await this.deps.transport.verify({
                 licenseKey: trimmedLicenseKey,
                 productId: this.config.productId,
                 instanceName: this.config.instanceName,
+                instanceId: current.licenseKey === trimmedLicenseKey ? current.instanceId : undefined,
             });
         }
         catch (error) {
@@ -451,7 +456,9 @@ class LicenseCore {
         }
         const activationLimit = toNonNegativeNumber(verifyResult.activationLimit, 0);
         const activationUsage = toNonNegativeNumber(verifyResult.activationUsage, 0);
-        if (isActivationLimitReached(activationLimit, activationUsage)) {
+        // A verified instance already occupies its seat. usage === limit is not
+        // an error after successful activation (e.g. the first device on a 1-seat key).
+        if (!verifyResult.instanceId && isActivationLimitReached(activationLimit, activationUsage)) {
             throw new LicenseCoreError(exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED, '활성화 가능한 기기 수를 모두 사용했습니다. 기존 기기를 비활성화한 뒤 다시 시도해 주세요.', verifyResult);
         }
         const current = await this.getStatus();
@@ -791,12 +798,14 @@ function asRecord$1(value) {
 }
 function failureMessageForStatus(status) {
     switch (status) {
+        case 'activation_limit_reached':
+            return '이 라이선스의 활성화 기기 수를 초과했습니다. 기존 기기에서 먼저 비활성화해 주세요.';
         case 'not_started':
             return '이번 달 라이선스의 사용 기간이 아직 시작되지 않았습니다.';
         case 'expired':
-            return '라이선스가 만료되었습니다. 이번 달 키를 다시 확인해 주세요.';
+            return '라이선스가 만료되었습니다. 새 키를 확인해 주세요.';
         case 'revoked':
-            return '사용 중지된 라이선스입니다. 새 키를 확인해 주세요.';
+            return '사용 중지된 라이선스입니다. 구매 내역이나 관리자에게 문의해 주세요.';
         case 'product_not_allowed':
             return '이 라이선스는 현재 플러그인에서 사용할 수 없습니다.';
         case 'rate_limited':
@@ -812,9 +821,12 @@ function defaultNormalizeVerifyResponse(raw) {
     const statusValid = typeof licenseStatus === 'string'
         ? licenseStatus.toLowerCase() === 'active'
         : undefined;
-    const valid = readBooleanField(body, ['valid', 'success', 'active'])
+    const rejectedStatus = ['expired', 'revoked', 'invalid', 'inactive', 'not_started',
+        'product_not_allowed', 'rate_limited', 'activation_limit_reached', 'environment_mismatch', 'mode_unverified']
+        .includes(licenseStatus?.trim().toLowerCase() || '');
+    const valid = !rejectedStatus && (readBooleanField(body, ['valid', 'success', 'active'])
         ?? statusValid
-        ?? false;
+        ?? false);
     const normalizedStatus = licenseStatus?.trim().toLowerCase();
     const fallbackMessage = !valid ? failureMessageForStatus(normalizedStatus) : undefined;
     const message = readTextField(body, ['message', 'error', 'detail']) || fallbackMessage;
@@ -1189,6 +1201,205 @@ class DesignbaseAccountLicenseTransport {
     }
 }
 
+/** Copy legacy storage once. Paid status is revalidated before any UI is published. */
+async function migrateLegacyLicenseStorage(storage, prefix, keys = {}) {
+    const oldKey = (field) => {
+        const oldPrefix = keys.sourcePrefix ? `${keys.sourcePrefix}:` : '';
+        return `${oldPrefix}${keys[field] || field}`;
+    };
+    const marker = `${prefix}:legacyMigration`;
+    if (await storage.get(marker))
+        return;
+    const existing = await storage.get(`${prefix}:paymentStatus`);
+    if (existing === undefined || existing === null) {
+        const key = await storage.get(oldKey('licenseKey'));
+        const instanceId = await storage.get(oldKey('instanceId'));
+        const paymentStatus = await storage.get(oldKey('paymentStatus'));
+        const usage = await storage.get(oldKey('usageCount'));
+        if (typeof key === 'string' && key.trim()) {
+            await storage.set(`${prefix}:licenseKey`, key.trim());
+            await storage.set(`${prefix}:instanceId`, typeof instanceId === 'string' ? instanceId : '');
+            await storage.set(`${prefix}:planTier`, paymentStatus === 'PAID' ? 'PAID' : 'FREE');
+        }
+        if (typeof usage === 'number' && Number.isFinite(usage) && usage >= 0) {
+            await storage.set(`${prefix}:usageCount`, Math.floor(usage));
+        }
+        if (typeof key === 'string' && key.trim()) {
+            await storage.set(`${prefix}:paymentStatus`, paymentStatus === 'PAID' ? 'PAID' : 'FREE');
+        }
+    }
+    // Do not delete legacy keys: another version may still need them for rollback.
+    await storage.set(marker, 1);
+}
+async function readOrCreateDeviceId(storage, prefix) {
+    const storageKey = `${prefix}:deviceId`;
+    const current = await storage.get(storageKey);
+    if (typeof current === 'string' && current.length > 0)
+        return current;
+    const legacy = await storage.get('licenseDeviceId');
+    const nonce = `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+    const device = typeof legacy === 'string' && legacy.length > 0
+        ? legacy
+        : `license-${Date.now().toString(36)}-${nonce}`;
+    await storage.set(storageKey, device);
+    return device;
+}
+const pendingDeviceIds = new WeakMap();
+async function getPersistentLicenseDeviceId(storage, prefix) {
+    let pending = pendingDeviceIds.get(storage);
+    if (!pending) {
+        pending = new Map();
+        pendingDeviceIds.set(storage, pending);
+    }
+    const existing = pending.get(prefix);
+    if (existing)
+        return existing;
+    const request = readOrCreateDeviceId(storage, prefix);
+    pending.set(prefix, request);
+    try {
+        return await request;
+    }
+    finally {
+        pending.delete(prefix);
+    }
+}
+
+const errors = {
+    expired: [
+        exports.LicenseErrorCode.LICENSE_EXPIRED,
+        '라이선스가 만료되었습니다. 구매 내역 또는 이번 달 멤버십 키를 확인해 주세요.',
+    ],
+    revoked: [exports.LicenseErrorCode.LICENSE_REVOKED, '사용 중지된 라이선스입니다.'],
+    not_started: [
+        exports.LicenseErrorCode.INVALID_LICENSE,
+        '라이선스 사용 기간이 아직 시작되지 않았습니다.',
+    ],
+    product_not_allowed: [
+        exports.LicenseErrorCode.PRODUCT_MISMATCH,
+        '이 라이선스는 현재 플러그인 구매 키가 아닙니다.',
+    ],
+    environment_mismatch: [
+        exports.LicenseErrorCode.INVALID_LICENSE,
+        '테스트 구매 키는 테스트 인증 서버에서만 사용할 수 있습니다.',
+    ],
+    mode_unverified: [
+        exports.LicenseErrorCode.NETWORK_ERROR,
+        '라이선스의 테스트·운영 구분을 확인하지 못했습니다.',
+    ],
+    rate_limited: [
+        exports.LicenseErrorCode.RATE_LIMITED,
+        '인증 요청이 너무 많습니다. 잠시 후 다시 시도해 주세요.',
+    ],
+    network_error: [
+        exports.LicenseErrorCode.NETWORK_ERROR,
+        '라이선스 서버에 연결하지 못했습니다. 다시 시도해 주세요.',
+    ],
+    activation_limit_reached: [
+        exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED,
+        '사용 가능한 기기 수를 모두 사용했습니다. 다른 기기에서 해제해 주세요.',
+    ],
+    activation_required: [exports.LicenseErrorCode.INVALID_LICENSE, '라이선스를 다시 인증해 주세요.'],
+    invalid_instance: [
+        exports.LicenseErrorCode.INVALID_LICENSE,
+        '이 기기의 인증 정보가 만료되었습니다. 다시 인증해 주세요.',
+    ],
+};
+function normalizeWordPressLicenseResponse(raw, productId) {
+    const data = raw && typeof raw === 'object' ? raw : {};
+    const status = typeof data.status === 'string' ? data.status : 'invalid';
+    if (data.valid !== true || status !== 'active') {
+        const [code, message] = errors[status] || [
+            exports.LicenseErrorCode.INVALID_LICENSE,
+            '유효하지 않은 라이선스 키입니다.',
+        ];
+        throw new LicenseCoreError(code, message, undefined, code === exports.LicenseErrorCode.NETWORK_ERROR || code === exports.LicenseErrorCode.RATE_LIMITED);
+    }
+    if (data.product_id !== productId) {
+        throw new LicenseCoreError(exports.LicenseErrorCode.PRODUCT_MISMATCH, '인증 서버의 상품 정보가 일치하지 않습니다.');
+    }
+    const source = typeof data.source === 'string' ? data.source : '';
+    if (data.provider === 'lemon_api' &&
+        (typeof data.instance_id !== 'string' || !data.instance_id)) {
+        throw new LicenseCoreError(exports.LicenseErrorCode.INVALID_LICENSE, '기기 활성화 정보를 확인하지 못했습니다.');
+    }
+    return {
+        valid: true,
+        productId,
+        planTier: 'PAID',
+        licenseStatus: 'active',
+        instanceId: typeof data.instance_id === 'string' ? data.instance_id : undefined,
+        activationLimit: typeof data.activation_limit === 'number' ? data.activation_limit : 0,
+        activationUsage: typeof data.activation_usage === 'number' ? data.activation_usage : 0,
+        licenseSource: source,
+        accessScope: typeof data.access_scope === 'string' ? data.access_scope : 'product',
+        expiresAt: typeof data.expires_at === 'string' ? data.expires_at : undefined,
+    };
+}
+function createWordPressLicenseTransport(options) {
+    const { storage, storagePrefix: prefix, productId } = options;
+    if (!productId.trim() || !prefix.trim())
+        throw new Error('productId and storagePrefix are required.');
+    if (!/^https:\/\//i.test(options.baseUrl) &&
+        !/^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?(\/|$)/i.test(options.baseUrl)) {
+        throw new Error('License server must use HTTPS (HTTP is allowed only for local development).');
+    }
+    const timeout = options.timeoutMs || 20000;
+    const fetchFn = options.fetchFn || fetch;
+    const body = (payload) => ({
+        license_key: payload.licenseKey,
+        product_id: productId,
+        instance_id: payload.instanceId || '',
+        device_id: payload.deviceId,
+    });
+    const base = options.baseUrl.replace(/\/$/, '');
+    const http = new FetchLicenseTransport({
+        verifyUrl: `${base}/activate`,
+        validateUrl: `${base}/validate`,
+        deactivateUrl: `${base}/deactivate`,
+        fetchFn,
+        useAbortSignal: false,
+        timeoutMs: timeout,
+        buildVerifyBody: body,
+        buildValidateBody: body,
+        buildDeactivateBody: body,
+        normalizeVerifyResponse: (raw) => normalizeWordPressLicenseResponse(raw, productId),
+        normalizeDeactivateResponse: (raw) => {
+            const data = raw && typeof raw === 'object' ? raw : {};
+            const success = data.success === true || data.deactivated === true;
+            return {
+                success,
+                message: success
+                    ? undefined
+                    : '라이선스 연결을 해제하지 못했습니다. 다시 시도해 주세요.',
+            };
+        },
+    });
+    const enrich = async (payload) => ({
+        ...payload,
+        deviceId: await getPersistentLicenseDeviceId(storage, prefix),
+    });
+    return {
+        verify: async (payload) => {
+            const storedKey = await storage.get(`${prefix}:licenseKey`);
+            const storedInstance = await storage.get(`${prefix}:instanceId`);
+            return http.verify(await enrich({
+                ...payload,
+                instanceId: payload.instanceId ||
+                    (storedKey === payload.licenseKey && typeof storedInstance === 'string'
+                        ? storedInstance
+                        : ''),
+            }));
+        },
+        validate: async (payload) => {
+            const enriched = await enrich(payload);
+            // Legacy users may not have a Lemon instance yet. Activate once;
+            // the server reuses its device mapping when a response was lost.
+            return payload.instanceId ? http.validate(enriched) : http.verify(enriched);
+        },
+        deactivate: async (payload) => http.deactivate(await enrich(payload)),
+    };
+}
+
 class FigmaStorageAdapter {
     constructor(figma) {
         this.figma = figma;
@@ -1233,6 +1444,7 @@ const DEFAULT_LICENSE_MESSAGE_TYPES = {
 class FigmaLicenseStatusManager {
     constructor(options) {
         this.options = options;
+        this.messageQueue = Promise.resolve();
         this.messageTypes = {
             ...DEFAULT_LICENSE_MESSAGE_TYPES,
             ...(options.messageTypes || {}),
@@ -1242,6 +1454,7 @@ class FigmaLicenseStatusManager {
     async initialize() {
         if (!this.initializationPromise) {
             this.initializationPromise = (async () => {
+                await this.options.beforeInitialize?.();
                 const state = await this.options.core.initialize();
                 await this.postStatusUpdate(state);
             })().catch((error) => {
@@ -1251,7 +1464,12 @@ class FigmaLicenseStatusManager {
         }
         await this.initializationPromise;
     }
-    async handleMessage(pluginMessage) {
+    handleMessage(pluginMessage) {
+        const operation = this.messageQueue.then(() => this.handleMessageNow(pluginMessage));
+        this.messageQueue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async handleMessageNow(pluginMessage) {
         if (!pluginMessage || typeof pluginMessage !== 'object') {
             return false;
         }
@@ -1265,15 +1483,18 @@ class FigmaLicenseStatusManager {
             return true;
         }
         if (type === this.messageTypes.verifyLicense) {
+            await this.initialize();
             const licenseKey = typeof message.licenseKey === 'string' ? message.licenseKey : '';
             await this.handleVerifyLicense(licenseKey);
             return true;
         }
         if (type === this.messageTypes.deactivateLicense) {
+            await this.initialize();
             await this.handleDeactivateLicense();
             return true;
         }
         if (type === this.messageTypes.checkFeatureAccess) {
+            await this.initialize();
             const featureKey = typeof message.featureKey === 'string' ? message.featureKey : undefined;
             const amount = typeof message.amount === 'number' && Number.isFinite(message.amount) && message.amount > 0
                 ? message.amount
@@ -1282,6 +1503,7 @@ class FigmaLicenseStatusManager {
             return true;
         }
         if (type === this.messageTypes.consumeUsage) {
+            await this.initialize();
             const amount = typeof message.amount === 'number' && Number.isFinite(message.amount) && message.amount > 0
                 ? message.amount
                 : 1;
@@ -1305,6 +1527,7 @@ class FigmaLicenseStatusManager {
      * This is the preferred guard for operations handled entirely in main.
      */
     async canUseFeature(featureKey, amount = 1) {
+        await this.initialize();
         const state = await this.options.core.getStatus();
         const safeAmount = Number.isFinite(amount) && amount > 0 ? amount : 1;
         return this.options.core.resolveUsageAccess(state, featureKey, safeAmount);
@@ -1313,6 +1536,7 @@ class FigmaLicenseStatusManager {
      * Consume usage from main code and publish the refreshed status to the UI.
      */
     async consumeUsage(amount = 1, featureKey) {
+        await this.initialize();
         const result = await this.options.core.consumeUsage(amount, featureKey);
         await this.postStatusUpdate(result.state);
         return result;
@@ -1449,14 +1673,21 @@ function createFigmaLicenseStatusManager(options) {
     const figmaApi = resolveFigmaApi(options.figma);
     const storage = options.storage ?? new FigmaStorageAdapter(figmaApi);
     const notifier = options.notifier ?? new FigmaNotifierAdapter(figmaApi);
-    const transport = options.transport ?? new FetchLicenseTransport({
-        verifyUrl: options.config.endpoint,
-        validateUrl: options.config.validateEndpoint,
-        deactivateUrl: options.config.deactivateEndpoint,
-        headers: options.config.requestHeaders,
-        timeoutMs: options.config.requestTimeoutMs,
-        fetchFn: options.fetchFn,
-    });
+    const prefix = options.config.storagePrefix?.trim() || `${options.config.instanceName}:${options.config.productId}`;
+    const transport = options.transport ?? (options.wordpress
+        ? createWordPressLicenseTransport({
+            baseUrl: options.wordpress.baseUrl, productId: options.config.productId,
+            storagePrefix: prefix, storage, fetchFn: options.fetchFn,
+            timeoutMs: options.config.requestTimeoutMs,
+        })
+        : new FetchLicenseTransport({
+            verifyUrl: options.config.endpoint,
+            validateUrl: options.config.validateEndpoint,
+            deactivateUrl: options.config.deactivateEndpoint,
+            headers: options.config.requestHeaders,
+            timeoutMs: options.config.requestTimeoutMs,
+            fetchFn: options.fetchFn,
+        }));
     const coreDependencies = {
         storage,
         transport,
@@ -1468,6 +1699,26 @@ function createFigmaLicenseStatusManager(options) {
         core,
         notifier,
         messageTypes: options.messageTypes,
+        beforeInitialize: options.migrateLegacyStorage
+            ? () => migrateLegacyLicenseStorage(storage, prefix, typeof options.migrateLegacyStorage === 'object' ? options.migrateLegacyStorage : undefined)
+            : undefined,
+    });
+}
+/** Shared membership + Lemon gateway setup. Product allowlists stay on the server. */
+function createWordPressFigmaLicenseManager(options) {
+    const base = options.serverBaseUrl.replace(/\/$/, '');
+    return createFigmaLicenseStatusManager({
+        figma: options.figma, storage: options.storage, notifier: options.notifier,
+        fetchFn: options.fetchFn, messageTypes: options.messageTypes,
+        migrateLegacyStorage: options.migrateLegacyStorage ?? true,
+        wordpress: { baseUrl: base },
+        config: {
+            productId: options.productId, instanceName: options.instanceName || options.productId,
+            storagePrefix: options.storagePrefix || `designbase:${options.productId}`,
+            endpoint: `${base}/activate`, validateEndpoint: `${base}/validate`, deactivateEndpoint: `${base}/deactivate`,
+            requestTimeoutMs: options.timeoutMs || 20000,
+            policy: options.policy,
+        },
     });
 }
 
@@ -1482,8 +1733,13 @@ exports.LicenseCore = LicenseCore;
 exports.LicenseCoreError = LicenseCoreError;
 exports.LicenseTransportHttpError = LicenseTransportHttpError;
 exports.createFigmaLicenseStatusManager = createFigmaLicenseStatusManager;
+exports.createWordPressFigmaLicenseManager = createWordPressFigmaLicenseManager;
+exports.createWordPressLicenseTransport = createWordPressLicenseTransport;
 exports.defaultNormalizeDeactivateResponse = defaultNormalizeDeactivateResponse;
 exports.defaultNormalizeVerifyResponse = defaultNormalizeVerifyResponse;
+exports.getPersistentLicenseDeviceId = getPersistentLicenseDeviceId;
 exports.isActivationLimitReached = isActivationLimitReached;
 exports.mapLicenseError = mapLicenseError;
+exports.migrateLegacyLicenseStorage = migrateLegacyLicenseStorage;
+exports.normalizeWordPressLicenseResponse = normalizeWordPressLicenseResponse;
 //# sourceMappingURL=index.js.map