tetrons 2.2.5 → 2.2.7

package/dist/app/api/register/route.d.ts

@@ -3,4 +3,5 @@ export declare function POST(req: NextRequest): Promise<NextResponse<{
     error: string;
 }> | NextResponse<{
     apiKey: string;
+    expiresAt: Date | null;
 }>>;

package/dist/app/api/register/route.js

@@ -1,26 +1,32 @@
 import { NextResponse } from "next/server";
 import { connectDB } from "../../../lib/db";
 import { ApiKey } from "../../../models/ApiKey";
-import { generateApiKey } from "../../../utils/apiKeyUtils";
+import { generateUserApiKey, getFreeApiKey } from "../../../utils/apiKeyUtils";
 export async function POST(req) {
-    const { email, organization, version } = await req.json();
-    if (!email || !organization || !version)
+    const body = await req.json();
+    const { email, organization, version } = body;
+    if (!email || !organization || !version) {
         return NextResponse.json({ error: "Missing fields" }, { status: 400 });
+    }
     await connectDB();
+    const lowerEmail = email.trim().toLowerCase();
+    const lowerOrg = organization.trim().toLowerCase();
+    await ApiKey.deleteMany({ email: lowerEmail, version });
+    let apiKey;
+    let expiresAt = null;
     if (version === "free") {
-        const expiresAt = new Date(Date.now() + 14 * 24 * 60 * 60 * 1000);
-        const apiKey = generateApiKey(48);
-        await ApiKey.deleteMany({ email, version });
-        await ApiKey.create({
-            email,
-            organization,
-            version,
-            apiKey,
-            expiresAt,
-        });
-        return NextResponse.json({ apiKey, expiresAt });
+        apiKey = getFreeApiKey();
+        expiresAt = new Date(Date.now() + 14 * 24 * 60 * 60 * 1000);
+    }
+    else {
+        apiKey = generateUserApiKey(lowerEmail, lowerOrg, version);
     }
-    const apiKey = generateApiKey(48);
-    await ApiKey.create({ email, organization, version, apiKey });
-    return NextResponse.json({ apiKey });
+    await ApiKey.create({
+        email: lowerEmail,
+        organization: lowerOrg,
+        version,
+        apiKey,
+        expiresAt,
+    });
+    return NextResponse.json({ apiKey, expiresAt });
 }

package/dist/app/api/validate/route.d.ts

@@ -1,7 +1,10 @@
 import { NextRequest, NextResponse } from "next/server";
+export declare function OPTIONS(): Promise<Response>;
 export declare function POST(req: NextRequest): Promise<NextResponse<{
     error: string;
 }> | NextResponse<{
     valid: boolean;
     version: any;
+    email: any;
+    organization: any;
 }>>;

package/dist/app/api/validate/route.js

@@ -1,18 +1,58 @@
 import { NextResponse } from "next/server";
 import { connectDB } from "../../../lib/db";
 import { ApiKey } from "../../../models/ApiKey";
+const corsHeaders = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+};
+export async function OPTIONS() {
+    return new Response(null, {
+        status: 204,
+        headers: corsHeaders,
+    });
+}
 export async function POST(req) {
-    const { apiKey } = await req.json();
-    if (!apiKey)
-        return NextResponse.json({ error: "API key required" }, { status: 400 });
-    await connectDB();
-    const keyEntry = await ApiKey.findOne({ apiKey });
-    if (!keyEntry)
-        return NextResponse.json({ error: "Invalid key" }, { status: 401 });
-    if (keyEntry.version === "free" &&
-        keyEntry.expiresAt &&
-        new Date() > new Date(keyEntry.expiresAt)) {
-        return NextResponse.json({ error: "Free trial expired" }, { status: 403 });
+    try {
+        const body = (await req.json());
+        const apiKey = body.apiKey;
+        if (!apiKey) {
+            return NextResponse.json({ error: "API key required" }, {
+                status: 400,
+                headers: corsHeaders,
+            });
+        }
+        await connectDB();
+        const keyEntry = await ApiKey.findOne({ apiKey });
+        if (!keyEntry) {
+            return NextResponse.json({ error: "Invalid API key" }, {
+                status: 401,
+                headers: corsHeaders,
+            });
+        }
+        if (keyEntry.version === "free" &&
+            keyEntry.expiresAt &&
+            new Date() > new Date(keyEntry.expiresAt)) {
+            return NextResponse.json({ error: "Free trial expired" }, {
+                status: 403,
+                headers: corsHeaders,
+            });
+        }
+        return NextResponse.json({
+            valid: true,
+            version: keyEntry.version,
+            email: keyEntry.email,
+            organization: keyEntry.organization,
+        }, {
+            status: 200,
+            headers: corsHeaders,
+        });
+    }
+    catch (err) {
+        console.error("Validation Error:", err);
+        return NextResponse.json({ error: "Server error" }, {
+            status: 500,
+            headers: corsHeaders,
+        });
     }
-    return NextResponse.json({ valid: true, version: keyEntry.version });
 }

package/dist/app/page.jsx

@@ -1,58 +1,47 @@
 "use client";
 import { useEffect, useState } from "react";
-import { useSearchParams } from "next/navigation";
 import EditorContent from "../components/tetrons/EditorContent";
 import "../styles/tetrons.css";
 export default function Home() {
-    const searchParams = useSearchParams();
-    const urlKey = searchParams.get("apiKey");
     const [apiKey, setApiKey] = useState(null);
     const [loading, setLoading] = useState(true);
     useEffect(() => {
-        const fetchApiKey = async () => {
-            try {
-                if (urlKey) {
-                    setApiKey(urlKey);
-                    localStorage.setItem("my-api-key", urlKey);
-                    setLoading(false);
-                    return;
+        const fetchOrGenerateApiKey = async () => {
+            let key = localStorage.getItem("tetrons-key");
+            if (!key) {
+                try {
+                    const res = await fetch("/api/register", {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            email: "developer@finapsys.co.in",
+                            organization: "FCSPL",
+                            version: "free",
+                        }),
+                    });
+                    const data = await res.json();
+                    if (!res.ok || !data.apiKey) {
+                        throw new Error(data.error || "Failed to register for API key");
+                    }
+                    key = data.apiKey;
+                    if (key) {
+                        localStorage.setItem("tetrons-key", key);
+                    }
                 }
-                const cachedKey = localStorage.getItem("my-api-key");
-                if (cachedKey) {
-                    setApiKey(cachedKey);
-                    setLoading(false);
-                    return;
+                catch (err) {
+                    console.error("❌ Failed to fetch or register API key:", err);
                 }
-                const res = await fetch("/api/register", {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        email: "mr.swastikjha@gmail.com",
-                        organization: "FCSPL",
-                        version: "free",
-                    }),
-                });
-                const data = await res.json();
-                if (!res.ok || !data.apiKey) {
-                    throw new Error(data.error || "Failed to fetch API key");
-                }
-                localStorage.setItem("my-api-key", data.apiKey);
-                setApiKey(data.apiKey);
-            }
-            catch (error) {
-                console.error("Error fetching API key:", error);
-            }
-            finally {
-                setLoading(false);
             }
+            setApiKey(key);
+            setLoading(false);
         };
-        fetchApiKey();
-    }, [urlKey]);
+        fetchOrGenerateApiKey();
+    }, []);
     if (loading) {
         return <div className="text-center p-4">⏳ Loading Editor...</div>;
     }
     if (!apiKey) {
-        return (<div className="text-center text-red-600">❌ Failed to load API key</div>);
+        return <div className="text-red-600 text-center">❌ API key not found</div>;
     }
     return (<main className="flex flex-col h-screen overflow-hidden">
       <div className="flex-1 overflow-auto flex flex-col">

package/dist/components/tetrons/EditorContent.jsx

@@ -49,11 +49,25 @@ export default function EditorContent({ apiKey }) {
     const [isValid, setIsValid] = React.useState(null);
     const [error, setError] = React.useState(null);
     const [versions, setVersions] = React.useState([]);
+    const [userVersion, setUserVersion] = React.useState(null);
     const [currentVersionIndex, setCurrentVersionIndex] = React.useState(null);
+    function getApiBaseUrl() {
+        var _a, _b;
+        if (typeof import.meta !== "undefined" &&
+            ((_a = import.meta.env) === null || _a === void 0 ? void 0 : _a.VITE_TETRONS_API_URL)) {
+            return import.meta.env.VITE_TETRONS_API_URL;
+        }
+        if (typeof process !== "undefined" &&
+            ((_b = process.env) === null || _b === void 0 ? void 0 : _b.NEXT_PUBLIC_TETRONS_API_URL)) {
+            return process.env.NEXT_PUBLIC_TETRONS_API_URL;
+        }
+        return "http://localhost:3000";
+    }
+    const API_BASE_URL = getApiBaseUrl();
     useEffect(() => {
         const validateKey = async () => {
             try {
-                const res = await fetch("/api/validate", {
+                const res = await fetch(`${API_BASE_URL}/api/validate`, {
                     method: "POST",
                     headers: {
                         "Content-Type": "application/json",
@@ -64,6 +78,7 @@ export default function EditorContent({ apiKey }) {
                 if (!res.ok)
                     throw new Error(data.error || "Invalid API Key");
                 setIsValid(true);
+                setUserVersion(data.version);
             }
             catch (err) {
                 if (err instanceof Error) {
@@ -169,20 +184,21 @@ export default function EditorContent({ apiKey }) {
         return <div className="editor-loading">🔍 Validating license...</div>;
     }
     return (<div className="editor-container">
-      <div className="editor-toolbar">
-        <button type="button" onClick={saveVersion} disabled={!editor} className="editor-save-btn">
-          Save Version
-        </button>
+      {userVersion !== "free" && (<div className="editor-toolbar">
+          <button type="button" onClick={saveVersion} disabled={!editor} className="editor-save-btn">
+            Save Version
+          </button>
 
-        <div className="editor-versions-wrapper">
-          {versions.length === 0 && (<span className="editor-no-versions">No saved versions</span>)}
-          {versions.map((_, idx) => (<button type="button" key={idx} onClick={() => restoreVersion(idx)} className={`editor-version-btn ${idx === currentVersionIndex ? "active" : ""}`} title={`Restore Version ${idx + 1}`}>
-              {`V${idx + 1}`}
-            </button>))}
-        </div>
-      </div>
+          <div className="editor-versions-wrapper">
+            {versions.length === 0 && (<span className="editor-no-versions">No saved versions</span>)}
+            {versions.map((_, idx) => (<button type="button" key={idx} onClick={() => restoreVersion(idx)} className={`editor-version-btn ${idx === currentVersionIndex ? "active" : ""}`} title={`Restore Version ${idx + 1}`}>
+                {`V${idx + 1}`}
+              </button>))}
+          </div>
+        </div>)}
+
+      {editor && userVersion && (<TetronsToolbar editor={editor} version={userVersion}/>)}
 
-      {editor && <TetronsToolbar editor={editor}/>}
       <div ref={wrapperRef} className="editor-content-wrapper" onClick={handleEditorClick}>
         {editor ? (<>
             <TiptapEditorContent editor={editor}/>

package/dist/components/tetrons/toolbar/TetronsToolbar.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import type { Editor } from "@tiptap/react";
-export default function TetronsToolbar({ editor }: {
+export default function TetronsToolbar({ editor, version, }: {
     editor: Editor;
+    version: "free" | "pro" | "premium" | "platinum";
 }): React.JSX.Element;

package/dist/components/tetrons/toolbar/TetronsToolbar.jsx

@@ -1,5 +1,5 @@
 "use client";
-import React, { useEffect } from "react";
+import React, { useEffect, useState } from "react";
 import ActionGroup from "./ActionGroup";
 import ClipboardGroup from "./ClipboardGroup";
 import FontStyleGroup from "./FontStyleGroup";
@@ -7,8 +7,8 @@ import InsertGroup from "./InsertGroup";
 import ListAlignGroup from "./ListAlignGroup";
 import MiscGroup from "./MiscGroup";
 import FileGroup from "./FileGroup";
-export default function TetronsToolbar({ editor }) {
-    const [autoSave, setAutoSave] = React.useState(false);
+export default function TetronsToolbar({ editor, version, }) {
+    const [autoSave, setAutoSave] = useState(false);
     useEffect(() => {
         if (!editor)
             return;
@@ -28,17 +28,19 @@ export default function TetronsToolbar({ editor }) {
         };
     }, [autoSave, editor]);
     return (<div className="tetrons-toolbar">
-      <div className="group">
-        <input type="checkbox" id="autoSave" checked={autoSave} onChange={(e) => setAutoSave(e.target.checked)}/>
-        <label htmlFor="autoSave">Auto Save</label>
-      </div>
+      {version !== "free" && (<div className="group">
+          <input type="checkbox" id="autoSave" checked={autoSave} onChange={(e) => setAutoSave(e.target.checked)}/>
+          <label htmlFor="autoSave">Auto Save</label>
+        </div>)}
 
-      <FileGroup editor={editor}/>
+      {["pro", "premium", "platinum"].includes(version) && (<FileGroup editor={editor}/>)}
       <ClipboardGroup editor={editor}/>
       <FontStyleGroup editor={editor}/>
       <ListAlignGroup editor={editor}/>
-      <InsertGroup editor={editor}/>
-      <MiscGroup editor={editor}/>
-      <ActionGroup editor={editor}/>
+      {["premium", "platinum"].includes(version) && (<>
+          <InsertGroup editor={editor}/>
+          <ActionGroup editor={editor}/>
+        </>)}
+      {version === "platinum" && <MiscGroup editor={editor}/>}
     </div>);
 }

package/dist/index.d.ts

@@ -1,3 +1,7 @@
-export { default as EditorContent } from "./components/tetrons/EditorContent";
 import EditorContent from "./components/tetrons/EditorContent";
+import "./styles/tetrons.css";
+export declare function initializeTetrons(apiKey: string): Promise<void>;
+export declare function getTetronsVersion(): "" | "free" | "pro" | "premium" | "platinum";
+export declare function isApiKeyValid(): boolean;
+export { EditorContent };
 export default EditorContent;

package/dist/index.js

@@ -1,4 +1,28 @@
-export { default as EditorContent } from "./components/tetrons/EditorContent";
-// import "./styles/tetrons.css";
 import EditorContent from "./components/tetrons/EditorContent";
+import "./styles/tetrons.css";
+let API_VALID = false;
+let API_VERSION = "";
+export async function initializeTetrons(apiKey) {
+    const res = await fetch("http://localhost:3000/api/validate", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ apiKey }),
+    });
+    if (!res.ok) {
+        const error = await res.json();
+        throw new Error(`API Key validation failed: ${error.error}`);
+    }
+    const data = await res.json();
+    API_VALID = data.valid;
+    API_VERSION = data.version;
+}
+export function getTetronsVersion() {
+    return API_VERSION;
+}
+export function isApiKeyValid() {
+    return API_VALID;
+}
+export { EditorContent };
 export default EditorContent;

package/dist/utils/apiKeyUtils.d.ts

@@ -1,11 +1,11 @@
-/**
- * Generates a secure random API key
- * @param length Length of the key (default 48 characters)
- * @returns Hex string API key
- */
+export declare function getFreeApiKey(): string;
+declare const VERSION_PREFIXES: {
+    readonly pro: "PRO";
+    readonly premium: "PREMIUM";
+    readonly platinum: "PLATINUM";
+};
+export type VersionType = keyof typeof VERSION_PREFIXES;
+export declare function generateUserApiKey(email: string, organization: string, version: VersionType): string;
 export declare function generateApiKey(length?: number): string;
-/**
- * Generates a unique key with optional prefix (e.g., for versioning or branding)
- * @param prefix Optional prefix like 'PRO-', 'PREMIUM-', etc.
- */
 export declare function generateVersionedKey(prefix?: string): string;
+export {};

package/dist/utils/apiKeyUtils.js

@@ -1,17 +1,33 @@
 import crypto from "crypto";
-/**
- * Generates a secure random API key
- * @param length Length of the key (default 48 characters)
- * @returns Hex string API key
- */
+const FREE_API_KEY = process.env.TETRONS_FREE_KEY || "TETRONS_FREE_KEY";
+const SECRET_KEY = process.env.API_KEY_SECRET || "default-secret-key";
+export function getFreeApiKey() {
+    return FREE_API_KEY;
+}
+const VERSION_PREFIXES = {
+    pro: "PRO",
+    premium: "PREMIUM",
+    platinum: "PLATINUM",
+};
+export function generateUserApiKey(email, organization, version) {
+    const input = `${email.trim().toLowerCase()}:${organization
+        .trim()
+        .toLowerCase()}`;
+    const hash = crypto
+        .createHmac("sha256", SECRET_KEY)
+        .update(input)
+        .digest("hex")
+        .toUpperCase();
+    const prefix = VERSION_PREFIXES[version];
+    return `${prefix}${hash.slice(0, 48 - prefix.length)}`;
+}
 export function generateApiKey(length = 48) {
-    return crypto.randomBytes(length / 2).toString("hex"); // length must be even
+    return crypto
+        .randomBytes(length / 2)
+        .toString("hex")
+        .toUpperCase();
 }
-/**
- * Generates a unique key with optional prefix (e.g., for versioning or branding)
- * @param prefix Optional prefix like 'PRO-', 'PREMIUM-', etc.
- */
 export function generateVersionedKey(prefix = "") {
-    const key = generateApiKey(48);
+    const key = generateApiKey(48 - prefix.length);
     return `${prefix}${key}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tetrons",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "description": "A Next.js project written in TypeScript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",