testing-package-xdsfdsfsc 1.0.16 → 1.0.17

package/entitlement-check.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Runs inside the package on the server. Reads THIS package's package.json
+ * (same dir as this file), builds deviceId, calls backend. No consumer config needed.
+ */
+const { createHash } = require("crypto");
+const { readFileSync, existsSync } = require("fs");
+const { hostname, platform } = require("os");
+const { join } = require("path");
+
+function getXpackFromThisPackage() {
+	// This file lives in the package root; package.json is next to it
+	const pkgPath = join(__dirname, "package.json");
+	if (!existsSync(pkgPath)) return {};
+	try {
+		const raw = readFileSync(pkgPath, "utf-8");
+		const pkg = JSON.parse(raw);
+		return pkg.xpack || {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Call from Server Component or API. Returns { allowed: boolean }.
+ * Uses this package's own package.json for xpack (host, projectId, apiKey).
+ */
+async function getEntitlement() {
+	const xpack = getXpackFromThisPackage();
+	const host = (xpack.host || "").replace(/\/+$/, "");
+	const projectId = xpack.projectId || "";
+	const apiKey = xpack.apiKey || "";
+
+	if (!projectId || !apiKey || !host) {
+		return { allowed: false };
+	}
+
+	const deviceId = createHash("sha256")
+		.update(hostname() + "-" + platform())
+		.digest("hex");
+
+	try {
+		const res = await fetch(host + "/api/install/runtime-check", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ projectId, apiKey, deviceId }),
+		});
+		const data = await res.json();
+		return { allowed: data.allowed === true };
+	} catch {
+		return { allowed: false };
+	}
+}
+
+module.exports = { getEntitlement, getXpackFromThisPackage };

package/examples/entitlement-provider-server.tsx

@@ -0,0 +1,26 @@
+/**
+ * Server Component: runs entitlement check inside the package (reads this package's
+ * package.json, calls backend). No API route or root project config needed.
+ *
+ * Consumer usage (nothing else required):
+ *   import { EntitlementProvider } from "testing-package-xdsfdsfsc/examples/entitlement-provider-server";
+ *   import { Button } from "testing-package-xdsfdsfsc/examples/runtime-check-ui-example";
+ *   <EntitlementProvider><Button /></EntitlementProvider>
+ */
+
+import React, { type ReactNode } from "react";
+import { ClientEntitlementProvider } from "./runtime-check-ui-example";
+
+async function getEntitlement() {
+	const mod = await import("./entitlement-check.js");
+	return mod.getEntitlement();
+}
+
+export async function EntitlementProvider({ children }: { children: ReactNode }) {
+	const { allowed } = await getEntitlement();
+	return (
+		<ClientEntitlementProvider allowed={allowed}>
+			{children}
+		</ClientEntitlementProvider>
+	);
+}

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

@@ -1,24 +1,13 @@
+"use client";
 /**
- * Example: paid UI component library (like shadcn).
+ * Paid UI: use EntitlementProvider (Server Component) + Button. No API route or root config.
  *
- * Consumer usage:
- *
- *   import { XpackProvider, Button } from "@my-paid-ui";
- *
- *   function App() {
- *     return (
- *       <XpackProvider checkUrl="/api/entitlement-check">
- *         <Button>Click me</Button>
- *       </XpackProvider>
- *     );
+ *   import { EntitlementProvider, Button } from "your-package/examples/runtime-check-ui-example";
+ *   import { EntitlementProvider as ServerWrap } from "your-package/examples/entitlement-provider-server";
+ *   export default function Layout({ children }) {
+ *     return <ServerWrap><EntitlementProvider>{children}</EntitlementProvider></ServerWrap>;
  *   }
- *
- * 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.
+ *   // Or use XpackProvider + checkUrl if you prefer adding an API route.
  */
 
 import React, {
@@ -84,6 +73,26 @@ export function useEntitled(): EntitlementContextValue {
 	return ctx;
 }
 
+/** Client wrapper: receives server result and sets context. No fetch, no API route. */
+export function ClientEntitlementProvider({
+	allowed,
+	children,
+	payUrl,
+}: {
+	allowed: boolean;
+	children: ReactNode;
+	payUrl?: string;
+}) {
+	const value: EntitlementContextValue = allowed
+		? { status: "allowed" }
+		: { status: "denied", payUrl };
+	return (
+		<EntitlementContext.Provider value={value}>
+			{children}
+		</EntitlementContext.Provider>
+	);
+}
+
 /** Example: your Button uses the hook and blocks when not entitled */
 export function Button({
 	children,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "testing-package-xdsfdsfsc",
-	"version": "1.0.16",
+	"version": "1.0.17",
 	"description": "",
 	"main": "index.js",
 	"scripts": {
@@ -12,7 +12,8 @@
 	"files": [
 		"preinstall.js",
 		"index.js",
-		"examples"
+		"examples",
+		"entitlement-check.js"
 	],
 	"author": "",
 	"license": "ISC",