strapi-plugin-magic-mark 1.1.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    default: {};
+    validator: () => void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,82 @@
+declare const _default: {
+    bookmark: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+                comment: string;
+            };
+            pluginOptions: {
+                'content-manager': {
+                    visible: boolean;
+                };
+                'content-type-builder': {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                    maxLength: number;
+                    configurable: boolean;
+                };
+                path: {
+                    type: string;
+                    required: boolean;
+                    configurable: boolean;
+                    description: string;
+                };
+                query: {
+                    type: string;
+                    configurable: boolean;
+                    description: string;
+                };
+                emoji: {
+                    type: string;
+                    default: string;
+                    configurable: boolean;
+                    maxLength: number;
+                };
+                isPinned: {
+                    type: string;
+                    default: boolean;
+                    configurable: boolean;
+                };
+                order: {
+                    type: string;
+                    default: number;
+                    configurable: boolean;
+                };
+                description: {
+                    type: string;
+                    configurable: boolean;
+                };
+                sharedWithRoles: {
+                    type: string;
+                    configurable: boolean;
+                    description: string;
+                };
+                sharedWithUsers: {
+                    type: string;
+                    configurable: boolean;
+                    description: string;
+                };
+                isPublic: {
+                    type: string;
+                    default: boolean;
+                    configurable: boolean;
+                    description: string;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/controllers/controller.d.ts

@@ -0,0 +1,11 @@
+declare const _default: ({ strapi }: any) => {
+    getAll(ctx: any): Promise<any>;
+    create(ctx: any): Promise<any>;
+    update(ctx: any): Promise<any>;
+    delete(ctx: any): Promise<any>;
+    pin(ctx: any): Promise<any>;
+    reorder(ctx: any): Promise<any>;
+    getRoles(ctx: any): Promise<any>;
+    getUsers(ctx: any): Promise<any>;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    bookmarks: ({ strapi }: any) => {
+        getAll(ctx: any): Promise<any>;
+        create(ctx: any): Promise<any>;
+        update(ctx: any): Promise<any>;
+        delete(ctx: any): Promise<any>;
+        pin(ctx: any): Promise<any>;
+        reorder(ctx: any): Promise<any>;
+        getRoles(ctx: any): Promise<any>;
+        getUsers(ctx: any): Promise<any>;
+    };
+    license: ({ strapi }: any) => {
+        autoCreate(ctx: any): Promise<any>;
+        getStatus(ctx: any): Promise<any>;
+        createAndActivate(ctx: any): Promise<any>;
+        ping(ctx: any): Promise<any>;
+        storeKey(ctx: any): Promise<any>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/license.d.ts

@@ -0,0 +1,27 @@
+/**
+ * License Controller for MagicMark Plugin
+ * Manages licenses directly from the Admin Panel
+ */
+declare const _default: ({ strapi }: any) => {
+    /**
+     * Auto-create license with logged-in admin user data
+     */
+    autoCreate(ctx: any): Promise<any>;
+    /**
+     * Get current license status
+     */
+    getStatus(ctx: any): Promise<any>;
+    /**
+     * Create and activate a new license
+     */
+    createAndActivate(ctx: any): Promise<any>;
+    /**
+     * Manually ping the current license
+     */
+    ping(ctx: any): Promise<any>;
+    /**
+     * Store and validate an existing license key
+     */
+    storeKey(ctx: any): Promise<any>;
+};
+export default _default;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/index.d.ts

@@ -0,0 +1,195 @@
+/// <reference types="node" />
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: {};
+        validator: () => void;
+    };
+    controllers: {
+        bookmarks: ({ strapi }: any) => {
+            getAll(ctx: any): Promise<any>;
+            create(ctx: any): Promise<any>;
+            update(ctx: any): Promise<any>;
+            delete(ctx: any): Promise<any>;
+            pin(ctx: any): Promise<any>;
+            reorder(ctx: any): Promise<any>;
+            getRoles(ctx: any): Promise<any>;
+            getUsers(ctx: any): Promise<any>;
+        };
+        license: ({ strapi }: any) => {
+            autoCreate(ctx: any): Promise<any>;
+            getStatus(ctx: any): Promise<any>;
+            createAndActivate(ctx: any): Promise<any>;
+            ping(ctx: any): Promise<any>;
+            storeKey(ctx: any): Promise<any>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: any[];
+                };
+            }[];
+        };
+        'content-api': {
+            type: string;
+            routes: any[];
+        };
+    };
+    services: {
+        bookmarks: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            findAll(userId: number): Promise<any>;
+            create(name: string, path: string, query: string, emoji: string, description: string, userId: number, sharedWithRoles?: number[], sharedWithUsers?: number[], isPublic?: boolean): Promise<{
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }>;
+            update(id: string | number, data: any, userId: number): Promise<{
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }>;
+            delete(id: string | number): Promise<{
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }>;
+            pin(id: string | number, isPinned: boolean, userId: number): Promise<{
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            }>;
+            reorder(bookmarkIds: (string | number)[], userId: number): Promise<({
+                id: import("@strapi/types/dist/data").ID;
+            } & {
+                [key: string]: any;
+            })[]>;
+            validateUrl(url: string): boolean;
+        };
+        'license-guard': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getLicenseServerUrl(): string;
+            generateDeviceId(): string;
+            getDeviceName(): string;
+            getIpAddress(): string;
+            getUserAgent(): string;
+            createLicense({ email, firstName, lastName }: {
+                email: string;
+                firstName: string;
+                lastName: string;
+            }): Promise<import("./services/license-guard").LicenseData>;
+            verifyLicense(licenseKey: string, allowGracePeriod?: boolean): Promise<import("./services/license-guard").VerificationResult>;
+            pingLicense(licenseKey: string): Promise<any>;
+            getLicenseByKey(licenseKey: string): Promise<import("./services/license-guard").LicenseData>;
+            getOnlineStats(): Promise<any>;
+            startPinging(licenseKey: string, intervalMinutes?: number): NodeJS.Timeout;
+            initialize(): Promise<import("./services/license-guard").LicenseStatus>;
+            storeLicenseKey(licenseKey: string): Promise<boolean>;
+            cleanup(): void;
+        };
+    };
+    contentTypes: {
+        bookmark: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                    comment: string;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                        configurable: boolean;
+                    };
+                    path: {
+                        type: string;
+                        required: boolean;
+                        configurable: boolean;
+                        description: string;
+                    };
+                    query: {
+                        type: string;
+                        configurable: boolean;
+                        description: string;
+                    };
+                    emoji: {
+                        type: string;
+                        default: string;
+                        configurable: boolean;
+                        maxLength: number;
+                    };
+                    isPinned: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    order: {
+                        type: string;
+                        default: number;
+                        configurable: boolean;
+                    };
+                    description: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    sharedWithRoles: {
+                        type: string;
+                        configurable: boolean;
+                        description: string;
+                    };
+                    sharedWithUsers: {
+                        type: string;
+                        configurable: boolean;
+                        description: string;
+                    };
+                    isPublic: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+    policies: {
+        'license-check': (policyContext: any, config: any, { strapi }: any) => Promise<any>;
+    };
+    middlewares: {
+        'license-check': (config: any, { strapi }: any) => (ctx: any, next: any) => Promise<any>;
+    };
+};
+export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    'license-check': (config: any, { strapi }: any) => (ctx: any, next: any) => Promise<any>;
+};
+export default _default;

package/dist/server/src/middlewares/license-check.d.ts

@@ -0,0 +1,6 @@
+/**
+ * License Check Middleware
+ * Validates license before allowing plugin operations
+ */
+declare const _default: (config: any, { strapi }: any) => (ctx: any, next: any) => Promise<any>;
+export default _default;

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    'license-check': (policyContext: any, config: any, { strapi }: any) => Promise<any>;
+};
+export default _default;

package/dist/server/src/policies/license-check.d.ts

@@ -0,0 +1,6 @@
+/**
+ * License Check Policy
+ * Verifies that a valid license exists before allowing API access
+ */
+declare const _default: (policyContext: any, config: any, { strapi }: any) => Promise<any>;
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default _default;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: any[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    type: string;
+    routes: any[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: any[];
+            };
+        }[];
+    };
+    'content-api': {
+        type: string;
+        routes: any[];
+    };
+};
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+declare const _default: {
+    bookmarks: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        findAll(userId: number): Promise<any>;
+        create(name: string, path: string, query: string, emoji: string, description: string, userId: number, sharedWithRoles?: number[], sharedWithUsers?: number[], isPublic?: boolean): Promise<{
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }>;
+        update(id: string | number, data: any, userId: number): Promise<{
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }>;
+        delete(id: string | number): Promise<{
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }>;
+        pin(id: string | number, isPinned: boolean, userId: number): Promise<{
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        }>;
+        reorder(bookmarkIds: (string | number)[], userId: number): Promise<({
+            id: import("@strapi/types/dist/data").ID;
+        } & {
+            [key: string]: any;
+        })[]>;
+        validateUrl(url: string): boolean;
+    };
+    'license-guard': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getLicenseServerUrl(): string;
+        generateDeviceId(): string;
+        getDeviceName(): string;
+        getIpAddress(): string;
+        getUserAgent(): string;
+        createLicense({ email, firstName, lastName }: {
+            email: string;
+            firstName: string;
+            lastName: string;
+        }): Promise<import("./license-guard").LicenseData>;
+        verifyLicense(licenseKey: string, allowGracePeriod?: boolean): Promise<import("./license-guard").VerificationResult>;
+        pingLicense(licenseKey: string): Promise<any>;
+        getLicenseByKey(licenseKey: string): Promise<import("./license-guard").LicenseData>;
+        getOnlineStats(): Promise<any>;
+        startPinging(licenseKey: string, intervalMinutes?: number): NodeJS.Timeout;
+        initialize(): Promise<import("./license-guard").LicenseStatus>;
+        storeLicenseKey(licenseKey: string): Promise<boolean>;
+        cleanup(): void;
+    };
+};
+export default _default;

package/dist/server/src/services/license-guard.d.ts

@@ -0,0 +1,103 @@
+/**
+ * License Guard Service
+ * Handles license creation, verification, and ping tracking
+ */
+import type { Core } from '@strapi/strapi';
+export interface LicenseData {
+    licenseKey: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    isActive: boolean;
+    isExpired: boolean;
+    isOnline?: boolean;
+    expiresAt?: string;
+    lastPingAt?: string;
+    deviceName?: string;
+    deviceId?: string;
+    ipAddress?: string;
+    featurePremium?: boolean;
+    featureAdvanced?: boolean;
+    featureEnterprise?: boolean;
+    featureCustom?: boolean;
+    maxDevices?: number;
+    currentDevices?: number;
+}
+export interface VerificationResult {
+    valid: boolean;
+    data: LicenseData | null;
+    gracePeriod?: boolean;
+}
+export interface LicenseStatus {
+    valid: boolean;
+    demo?: boolean;
+    error?: string;
+    data?: LicenseData | null;
+}
+declare const licenseGuardService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Get license server URL (hardcoded and immutable for security)
+     * @returns The fixed license server URL - cannot be overridden
+     */
+    getLicenseServerUrl(): string;
+    /**
+     * Generate a unique device ID based on machine identifiers
+     */
+    generateDeviceId(): string;
+    /**
+     * Get device name
+     */
+    getDeviceName(): string;
+    /**
+     * Get server IP address
+     */
+    getIpAddress(): string;
+    /**
+     * Get user agent (server context)
+     */
+    getUserAgent(): string;
+    /**
+     * Create a license
+     */
+    createLicense({ email, firstName, lastName }: {
+        email: string;
+        firstName: string;
+        lastName: string;
+    }): Promise<LicenseData | null>;
+    /**
+     * Verify a license (with grace period support)
+     */
+    verifyLicense(licenseKey: string, allowGracePeriod?: boolean): Promise<VerificationResult>;
+    /**
+     * Ping a license (lightweight check)
+     */
+    pingLicense(licenseKey: string): Promise<any>;
+    /**
+     * Get license by key
+     */
+    getLicenseByKey(licenseKey: string): Promise<LicenseData | null>;
+    /**
+     * Get online statistics
+     */
+    getOnlineStats(): Promise<any>;
+    /**
+     * Start periodic pinging for a license
+     */
+    startPinging(licenseKey: string, intervalMinutes?: number): NodeJS.Timeout;
+    /**
+     * Initialize license guard
+     * Checks for existing license or prompts for creation
+     */
+    initialize(): Promise<LicenseStatus>;
+    /**
+     * Store license key after creation
+     */
+    storeLicenseKey(licenseKey: string): Promise<boolean>;
+    /**
+     * Cleanup on plugin destroy
+     */
+    cleanup(): void;
+};
+export default licenseGuardService;

package/dist/server/src/services/service.d.ts

@@ -0,0 +1,33 @@
+import type { Core } from '@strapi/strapi';
+declare const bookmarkService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    findAll(userId: number): Promise<any>;
+    create(name: string, path: string, query: string, emoji: string, description: string, userId: number, sharedWithRoles?: number[], sharedWithUsers?: number[], isPublic?: boolean): Promise<{
+        id: import("@strapi/types/dist/data").ID;
+    } & {
+        [key: string]: any;
+    }>;
+    update(id: string | number, data: any, userId: number): Promise<{
+        id: import("@strapi/types/dist/data").ID;
+    } & {
+        [key: string]: any;
+    }>;
+    delete(id: string | number): Promise<{
+        id: import("@strapi/types/dist/data").ID;
+    } & {
+        [key: string]: any;
+    }>;
+    pin(id: string | number, isPinned: boolean, userId: number): Promise<{
+        id: import("@strapi/types/dist/data").ID;
+    } & {
+        [key: string]: any;
+    }>;
+    reorder(bookmarkIds: (string | number)[], userId: number): Promise<({
+        id: import("@strapi/types/dist/data").ID;
+    } & {
+        [key: string]: any;
+    })[]>;
+    validateUrl(url: string): boolean;
+};
+export default bookmarkService;