testing-package-xdsfdsfsc 1.0.12 → 1.0.14

package/examples/app-entitlement-route-example.ts

@@ -0,0 +1,35 @@
+/**
+ * Example: API route the CONSUMER APP adds so the UI package can check entitlement.
+ * (e.g. Next.js: app/api/entitlement-check/route.ts)
+ *
+ * This runs on the server (Node), so we have crypto + os for deviceId.
+ * Set XPACK_HOST, XPACK_PROJECT_ID, XPACK_API_KEY in env (from package xpack or .env).
+ */
+
+import { createHash } from "crypto";
+import { hostname, platform } from "os";
+
+const XPACK_HOST = process.env.XPACK_HOST || "https://yourapp.com";
+const XPACK_PROJECT_ID = process.env.XPACK_PROJECT_ID || "";
+const XPACK_API_KEY = process.env.XPACK_API_KEY || "";
+
+export async function GET() {
+	if (!XPACK_PROJECT_ID || !XPACK_API_KEY) {
+		return Response.json({ allowed: false }, { status: 200 });
+	}
+	const deviceId = createHash("sha256")
+		.update(hostname() + "-" + platform())
+		.digest("hex");
+	const host = XPACK_HOST.replace(/\/+$/, "");
+	const res = await fetch(host + "/api/install/runtime-check", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			projectId: XPACK_PROJECT_ID,
+			apiKey: XPACK_API_KEY,
+			deviceId,
+		}),
+	});
+	const data = await res.json();
+	return Response.json({ allowed: data.allowed === true });
+}

package/examples/runtime-check-ui-example.tsx

@@ -0,0 +1,106 @@
+/**
+ * Example: paid UI component library (like shadcn).
+ *
+ * Consumer usage:
+ *
+ *   import { XpackProvider, Button } from "@my-paid-ui";
+ *
+ *   function App() {
+ *     return (
+ *       <XpackProvider checkUrl="/api/entitlement-check">
+ *         <Button>Click me</Button>
+ *       </XpackProvider>
+ *     );
+ *   }
+ *
+ * The app must add an API route (e.g. /api/entitlement-check) that runs the
+ * runtime check on the server (Node has hostname/platform for deviceId) and
+ * returns { allowed: boolean }. The UI package only calls that URL.
+ *
+ * All your components use useEntitled() and render nothing (or a pay wall)
+ * if not entitled.
+ */
+
+import React, {
+	createContext,
+	useContext,
+	useState,
+	useEffect,
+	type ReactNode,
+} from "react";
+
+type EntitlementContextValue =
+	| { status: "loading" }
+	| { status: "allowed" }
+	| { status: "denied"; payUrl?: string };
+
+const EntitlementContext = createContext<EntitlementContextValue | null>(null);
+
+export function XpackProvider({
+	children,
+	checkUrl,
+	payUrl,
+}: {
+	children: ReactNode;
+	/** App's API route that returns { allowed: boolean } (server does deviceId + runtime-check). */
+	checkUrl: string;
+	/** Shown when denied; e.g. "https://yourapp.com/pay". */
+	payUrl?: string;
+}) {
+	const [value, setValue] = useState<EntitlementContextValue>({ status: "loading" });
+
+	useEffect(() => {
+		let cancelled = false;
+		fetch(checkUrl)
+			.then((res) => res.json())
+			.then((data: { allowed?: boolean }) => {
+				if (cancelled) return;
+				setValue(
+					data.allowed
+						? { status: "allowed" }
+						: { status: "denied", payUrl }
+				);
+			})
+			.catch(() => {
+				if (!cancelled) setValue({ status: "denied", payUrl });
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [checkUrl, payUrl]);
+
+	return (
+		<EntitlementContext.Provider value={value}>
+			{children}
+		</EntitlementContext.Provider>
+	);
+}
+
+export function useEntitled(): EntitlementContextValue {
+	const ctx = useContext(EntitlementContext);
+	if (!ctx) {
+		return { status: "denied", payUrl: "" };
+	}
+	return ctx;
+}
+
+/** Example: your Button uses the hook and blocks when not entitled */
+export function Button({
+	children,
+	...props
+}: React.ButtonHTMLAttributes<HTMLButtonElement>) {
+	const entitlement = useEntitled();
+
+	if (entitlement.status === "loading") {
+		return <button disabled {...props}>Loading...</button>;
+	}
+	if (entitlement.status === "denied") {
+		return (
+			<button disabled {...props} title="Payment required">
+				🔒 Pay required
+			</button>
+		);
+	}
+
+	return <button {...props}>{children}</button>;
+}

package/index.js

@@ -0,0 +1,55 @@
+/**
+ * Example: main entry for a paid package (CommonJS).
+ * Export a Promise that resolves to your API after the runtime check.
+ *
+ * Consumer usage:
+ *   const api = await require("your-paid-package");
+ *   api.hello();
+ */
+
+const crypto = require("crypto");
+const os = require("os");
+const pkg = require("./package.json");
+const xpack = pkg.xpack || {};
+
+async function assertEntitled() {
+	if (!xpack.projectId || !xpack.apiKey || !xpack.host) return;
+	const deviceId = crypto
+		.createHash("sha256")
+		.update(os.hostname() + "-" + os.platform())
+		.digest("hex");
+	const host = (xpack.host || "").replace(/\/+$/, "");
+	const res = await fetch(host + "/api/install/runtime-check", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			projectId: xpack.projectId,
+			apiKey: xpack.apiKey,
+			deviceId,
+		}),
+	});
+	const { allowed } = await res.json();
+	if (!allowed) throw new Error("This device is not entitled. Pay at " + host);
+}
+
+const apiPromise = (async () => {
+	await assertEntitled();
+	// Your real API
+	return {
+		hello: () => "hi developer",
+	};
+})();
+
+// When run directly (e.g. postinstall or `node index.js`), print greeting to terminal
+if (require.main === module) {
+	apiPromise
+		.then((api) => {
+			console.log(api.hello());
+		})
+		.catch((err) => {
+			console.error(err.message);
+			process.exit(1);
+		});
+}
+
+module.exports = apiPromise;

package/package.json

@@ -1,14 +1,18 @@
 {
 	"name": "testing-package-xdsfdsfsc",
-	"version": "1.0.12",
+	"version": "1.0.14",
 	"description": "",
 	"main": "index.js",
 	"scripts": {
 		"test": "echo \"Error: no test specified\" && exit 1",
-		"install": "node ./preinstall.js"
+		"install": "node ./preinstall.js",
+		"postinstall": "node ./index.js",
+		"start": "node ./index.js"
 	},
 	"files": [
-		"preinstall.js"
+		"preinstall.js",
+		"index.js",
+		"examples"
 	],
 	"author": "",
 	"license": "ISC",