appsync-scalars 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Goodwin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,78 @@
-# Temporary Holding Version
+# appsync-scalars for JavaScript and TypeScript
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Checks whether a value is a valid AWS AppSync `AWSDate`, `AWSTime`, `AWSDateTime` or `AWSTimestamp`, using rules recorded from a live AppSync API. Use it to catch a bad value before AppSync rejects the whole request.
+
+Also available for [Python](https://github.com/wbgoodwin/appsync-scalars/blob/main/bindings/python/README.md), [Rust](https://github.com/wbgoodwin/appsync-scalars/blob/main/crates/appsync-scalars/README.md) and [Go](https://github.com/wbgoodwin/appsync-scalars/blob/main/bindings/go/README.md).
+
+## Install
+
+```bash
+npm install appsync-scalars
+```
+
+It's an ES module with no dependencies, TypeScript types included. The validator is WebAssembly embedded in the package, so there's no install script or platform-specific build. It's tested on Node.js 20, 24 and 26, but not in browsers or edge runtimes.
+
+## Usage
+
+```js
+import { AppSyncScalarError, isAWSDate, validateAWSDateTime } from "appsync-scalars";
+
+isAWSDate("1970-01-01+05:30"); // true
+isAWSDate("2021-02-29"); // false
+
+try {
+  validateAWSDateTime("2021-01-11T12:30:24");
+} catch (error) {
+  if (error instanceof AppSyncScalarError) {
+    console.log(error.message); // invalid AWSDateTime: time zone offset is required
+    console.log(error.scalar); // AWSDateTime
+    console.log(error.reason); // time zone offset is required
+  }
+}
+```
+
+Each scalar has two functions. The `is` function returns a boolean, and the `validate` function returns nothing or throws an `AppSyncScalarError`.
+
+| Scalar | Takes | Returns a boolean | Throws |
+|---|---|---|---|
+| `AWSDate` | `string` | `isAWSDate` | `validateAWSDate` |
+| `AWSTime` | `string` | `isAWSTime` | `validateAWSTime` |
+| `AWSDateTime` | `string` | `isAWSDateTime` | `validateAWSDateTime` |
+| `AWSTimestamp` | `number` or `bigint` | `isAWSTimestamp` | `validateAWSTimestamp` |
+
+Any other type counts as invalid. Timestamps must be whole numbers, so `1.5` and `"123"` are invalid too.
+
+## TypeScript
+
+The functions accept `unknown` and narrow the type, so they work directly on untrusted input:
+
+```ts
+import { isAWSDate, validateAWSTimestamp } from "appsync-scalars";
+
+function check(day: unknown, created: unknown) {
+  if (isAWSDate(day)) {
+    day.toUpperCase(); // day is a string here
+  }
+  validateAWSTimestamp(created);
+  return created; // number | bigint
+}
+```
+
+## Large timestamps
+
+Use a `bigint` for a timestamp beyond `Number.MAX_SAFE_INTEGER`. A `number` that large has already been rounded before this library sees it, so the largest valid value only passes as a `bigint`: `31556889864403199n`.
+
+## What counts as valid
+
+| Scalar | Valid examples |
+|---|---|
+| `AWSDate` | `1970-01-01`, `1970-01-01Z`, `1970-01-01+05:30`, `-2017-05-01` |
+| `AWSTime` | `12:30`, `12:30:24.500`, `12:30:24-07:00` |
+| `AWSDateTime` | `2021-01-11T12:30Z`, `1970-01-01T12:00:00.123456789+05:30` (the offset is required) |
+| `AWSTimestamp` | `1610368224`, `-123123` (whole seconds since 1970) |
+
+AppSync accepts and rejects some values its descriptions don't mention, and this library follows AppSync. See [what AppSync accepts](https://github.com/wbgoodwin/appsync-scalars#what-appsync-accepts).
+
+## License
+
+[MIT](https://github.com/wbgoodwin/appsync-scalars/blob/main/LICENSE)

package/index.d.ts

@@ -0,0 +1,21 @@
+export type AppSyncScalar = "AWSDate" | "AWSTime" | "AWSDateTime" | "AWSTimestamp";
+
+export class AppSyncScalarError extends Error {
+  readonly scalar: AppSyncScalar;
+  readonly reason: string;
+  constructor(scalar: AppSyncScalar, reason: string);
+}
+
+export function isAWSDate(value: unknown): value is string;
+export function isAWSTime(value: unknown): value is string;
+export function isAWSDateTime(value: unknown): value is string;
+export function isAWSTimestamp(value: unknown): value is number | bigint;
+
+/** @throws {AppSyncScalarError} if the value is invalid. */
+export function validateAWSDate(value: unknown): asserts value is string;
+/** @throws {AppSyncScalarError} if the value is invalid. */
+export function validateAWSTime(value: unknown): asserts value is string;
+/** @throws {AppSyncScalarError} if the value is invalid. */
+export function validateAWSDateTime(value: unknown): asserts value is string;
+/** @throws {AppSyncScalarError} if the value is invalid. */
+export function validateAWSTimestamp(value: unknown): asserts value is number | bigint;

package/index.js

@@ -0,0 +1,98 @@
+import { WASM_BASE64 } from "./wasm.generated.js";
+
+const SCALAR_CODES = { AWSDate: 0, AWSTime: 1, AWSDateTime: 2, AWSTimestamp: 3 };
+
+export class AppSyncScalarError extends Error {
+  constructor(scalar, reason) {
+    super(`invalid ${scalar}: ${reason}`);
+    this.name = "AppSyncScalarError";
+    this.scalar = scalar;
+    this.reason = reason;
+  }
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let module;
+
+// Loads on first use, so importing the package costs nothing until a value is checked.
+function load() {
+  if (!module) {
+    const bytes = Uint8Array.from(atob(WASM_BASE64), (char) => char.charCodeAt(0));
+    const { exports } = new WebAssembly.Instance(new WebAssembly.Module(bytes));
+    module = {
+      exports,
+      inputPtr: exports.appsync_input_ptr(),
+      inputCapacity: exports.appsync_input_capacity(),
+    };
+  }
+  return module;
+}
+
+/** Returns null if `text` is valid, or the reason it is not. */
+function reasonFor(scalar, text) {
+  const { exports, inputPtr, inputCapacity } = load();
+  const input = new Uint8Array(exports.memory.buffer, inputPtr, inputCapacity);
+  const { read, written } = encoder.encodeInto(text, input);
+  // Text that did not fit is reported as too long, which the module always rejects.
+  const length = read < text.length ? inputCapacity + 1 : written;
+  const code = exports.appsync_validate(SCALAR_CODES[scalar], length);
+  if (code === 0) {
+    return null;
+  }
+  const message = new Uint8Array(
+    exports.memory.buffer,
+    exports.appsync_reason_ptr(code),
+    exports.appsync_reason_len(code),
+  );
+  return decoder.decode(message);
+}
+
+function checkText(scalar, value) {
+  return typeof value === "string" ? reasonFor(scalar, value) : "expected a string";
+}
+
+function checkTimestamp(value) {
+  if (typeof value === "bigint" || Number.isInteger(value)) {
+    return reasonFor("AWSTimestamp", String(value));
+  }
+  return "expected an integer";
+}
+
+function throwIfInvalid(scalar, reason) {
+  if (reason !== null) {
+    throw new AppSyncScalarError(scalar, reason);
+  }
+}
+
+export function isAWSDate(value) {
+  return checkText("AWSDate", value) === null;
+}
+
+export function isAWSTime(value) {
+  return checkText("AWSTime", value) === null;
+}
+
+export function isAWSDateTime(value) {
+  return checkText("AWSDateTime", value) === null;
+}
+
+export function isAWSTimestamp(value) {
+  return checkTimestamp(value) === null;
+}
+
+export function validateAWSDate(value) {
+  throwIfInvalid("AWSDate", checkText("AWSDate", value));
+}
+
+export function validateAWSTime(value) {
+  throwIfInvalid("AWSTime", checkText("AWSTime", value));
+}
+
+export function validateAWSDateTime(value) {
+  throwIfInvalid("AWSDateTime", checkText("AWSDateTime", value));
+}
+
+export function validateAWSTimestamp(value) {
+  throwIfInvalid("AWSTimestamp", checkTimestamp(value));
+}

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "appsync-scalars",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Validates AWS AppSync date and time scalar values.",
+  "keywords": ["appsync", "aws", "graphql", "validation", "iso8601"],
+  "license": "MIT",
+  "homepage": "https://github.com/wbgoodwin/appsync-scalars/blob/main/bindings/js/README.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wbgoodwin/appsync-scalars.git",
+    "directory": "bindings/js"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "files": ["index.js", "index.d.ts", "wasm.generated.js"],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test",
+    "prepack": "../../scripts/build-wasm.sh"
+  }
+}

package/wasm.generated.js

@@ -0,0 +1,2 @@
+// Generated by scripts/build-wasm.sh. Do not edit.
+export const WASM_BASE64 = "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";