appsync-scalars 0.0.0-stage → 0.1.0

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,123 @@
-# Temporary Holding Version
+# appsync-scalars
 
-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.
+Validates the AWS AppSync date and time scalars (`AWSDate`, `AWSTime`, `AWSDateTime` and `AWSTimestamp`) with one Rust implementation, available in Rust, Python, JavaScript and Go.
+
+The rules come from results recorded from a live AppSync API, which differ from AWS's written descriptions. See [What AppSync accepts](#what-appsync-accepts).
+
+## Usage
+
+### Rust
+
+```rust
+use appsync_scalars::{is_aws_date, validate_aws_datetime};
+
+assert!(is_aws_date("1970-01-01+05:30"));
+
+// Err: invalid AWSDateTime: time zone offset is required
+validate_aws_datetime("2021-01-11T12:30:24").unwrap_err();
+```
+
+### Python
+
+```python
+from appsync_scalars import is_aws_date, validate_aws_datetime
+
+is_aws_date("1970-01-01+05:30")  # True
+validate_aws_datetime("2021-01-11T12:30:24")  # raises ValueError
+```
+
+The core package has no dependencies. Pydantic field types are an optional extra, installed with `pip install "appsync-scalars[pydantic]"`:
+
+```python
+from pydantic import BaseModel
+from appsync_scalars.pydantic import AWSDate, AWSDateTime, AWSTimestamp
+
+class Event(BaseModel):
+    day: AWSDate
+    starts_at: AWSDateTime
+    created: AWSTimestamp
+```
+
+Fields keep the exact `str` or `int` they were given, because Python's `datetime` cannot hold negative years and keeps only microseconds. They are also strict, so `"123"` is not converted to an integer for `AWSTimestamp`.
+
+### JavaScript and TypeScript
+
+```js
+import { isAWSDate, validateAWSDateTime } from "appsync-scalars";
+
+isAWSDate("1970-01-01+05:30"); // true
+validateAWSDateTime("2021-01-11T12:30:24"); // throws AppSyncScalarError
+```
+
+### Go
+
+```go
+import appsyncscalars "github.com/wbgoodwin/appsync-scalars/bindings/go"
+
+appsyncscalars.IsAWSDate("1970-01-01+05:30") // true
+err := appsyncscalars.ValidateAWSDateTime("2021-01-11T12:30:24") // *appsyncscalars.Error
+```
+
+`AWSTimestamp` functions take the integer's text in Go and Rust, and an integer in Python and JavaScript.
+
+## What AppSync accepts
+
+AppSync's descriptions of these scalars are accurate for ordinary values. It also accepts and rejects some values they don't mention, and this library follows AppSync:
+
+| Value | Example | AppSync's behavior |
+|---|---|---|
+| Lowercase `z` and `t` | `2021-01-11t12:30:24z` | Accepted |
+| Empty fraction | `12:00:34.` | Accepted |
+| Signed years of 5 to 10 digits | `+12021-01-11`, `-12021-01-11` | Accepted, up to 999,999,999 either way |
+| `+` with a 4-digit year | `+2021-01-11` | Rejected |
+| Negative year zero | `-0000-01-11` | Rejected |
+| Hours-only offset | `+05` | Accepted by `AWSDateTime`, rejected by `AWSDate` and `AWSTime` |
+| Offset beyond 18 hours | `+18:01` | Rejected by `AWSDateTime`, accepted by `AWSDate` and `AWSTime` up to `+23:59:59` |
+
+`AWSTimestamp` follows its documented limits, -31557014167219200 to 31556889864403199.
+
+AppSync gave the same verdict for a GraphQL variable and for resolver output on every recorded value. Inline literals differ in one way: AppSync wraps oversized integers, so `18446744073709551616` written in a query reaches the resolver as `0`. This library calls that value invalid, as AppSync does for variables and output.
+
+## How it fits together
+
+| Path | Purpose |
+|---|---|
+| [`crates/appsync-scalars`](https://github.com/wbgoodwin/appsync-scalars/blob/main/crates/appsync-scalars/src/lib.rs) | The validator: Rust with no dependencies |
+| [`crates/appsync-scalars-wasm`](https://github.com/wbgoodwin/appsync-scalars/blob/main/crates/appsync-scalars-wasm/src/lib.rs) | The WebAssembly module, about 4 KB, shared by JavaScript and Go |
+| [`bindings/python`](https://github.com/wbgoodwin/appsync-scalars/blob/main/bindings/python/pyproject.toml) | Native extension built with PyO3 and maturin, plus the Pydantic types |
+| [`bindings/js`](https://github.com/wbgoodwin/appsync-scalars/blob/main/bindings/js/index.js) | npm package that embeds the module, so it has no install step or platform-specific builds |
+| [`bindings/go`](https://github.com/wbgoodwin/appsync-scalars/blob/main/bindings/go/appsyncscalars.go) | Go module that runs the embedded module through wazero, with no cgo |
+| [`conformance/smoke.json`](https://github.com/wbgoodwin/appsync-scalars/blob/main/conformance/smoke.json) | Test cases every language runs |
+| [`conformance/`](https://github.com/wbgoodwin/appsync-scalars/blob/main/conformance/README.md) | The live AppSync test suite |
+
+Other languages with a WebAssembly runtime can load the same module. Its interface is described in [`crates/appsync-scalars-wasm/src/lib.rs`](https://github.com/wbgoodwin/appsync-scalars/blob/main/crates/appsync-scalars-wasm/src/lib.rs).
+
+## Development
+
+You need `rustup`, which installs the pinned Rust version, plus `uv`, Node.js 20 or later, and Go 1.25 or later.
+
+Run every language's tests:
+
+```bash
+scripts/test-all.sh
+```
+
+After changing the validator, rebuild the WebAssembly module and commit the Go copy, because `go get` only sees files in the repository:
+
+```bash
+scripts/build-wasm.sh
+```
+
+## Releasing
+
+GitHub Actions runs the tests, and builds and tests a wheel on Linux, macOS and Windows, for every pull request and push to `main`.
+
+To release, set the new version in `crates/appsync-scalars/Cargo.toml`, `bindings/python/pyproject.toml` and `bindings/js/package.json`, merge to `main`, then push a tag:
+
+```bash
+git tag v1.2.3 && git push origin v1.2.3
+```
+
+The workflow repeats every check, publishes to crates.io, PyPI and npm, and adds the `bindings/go/v1.2.3` tag Go needs. It skips anything already on a registry, so rerunning a partly failed release is safe.
+
+Publishing stores no tokens. Each registry needs a trusted publisher for this repository, with the workflow `ci.yml` and the environment `release`. PyPI can set one up before the first release. crates.io and npm need the first version published by hand, and npm's publisher must allow `npm publish`.

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,29 @@
 {
   "name": "appsync-scalars",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Validates AWS AppSync date and time scalar values.",
+  "keywords": ["appsync", "aws", "graphql", "validation", "iso8601"],
+  "license": "MIT",
+  "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": "cp ../../README.md . && ../../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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";