@xano/sdk 1.0.0

package/package.json

@@ -0,0 +1,162 @@
+{
+  "name": "@xano/sdk",
+  "version": "1.0.0",
+  "description": "Xano SDK — your Xano backend as TypeScript. `xanosdk deploy` ships your typed workspace (and an optional static frontend) to a live, auto-expiring ephemeral environment and prints its URL. init → deploy → URL.",
+  "keywords": [
+    "xanosdk",
+    "xano",
+    "sdk",
+    "typescript",
+    "deploy",
+    "ephemeral",
+    "preview-environments",
+    "infrastructure-as-code"
+  ],
+  "homepage": "https://github.com/xanots/sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xanots/sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xanots/sdk/issues"
+  },
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "xanosdk": "dist/bin.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "typesVersions": {
+    "*": {
+      "lambda-globals": [
+        "types/lambda-globals.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./scaffold": {
+      "types": "./dist/scaffold.d.ts",
+      "import": "./dist/scaffold.js"
+    },
+    "./codegen": {
+      "types": "./dist/codegen.d.ts",
+      "import": "./dist/codegen.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
+    },
+    "./bundle": {
+      "types": "./dist/bundle.d.ts",
+      "import": "./dist/bundle.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./sveltekit": {
+      "types": "./dist/sveltekit.d.ts",
+      "import": "./dist/sveltekit.js"
+    },
+    "./lambda-globals": {
+      "types": "./types/lambda-globals.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./manifest.json": "./manifest.json"
+  },
+  "files": [
+    "dist",
+    "types",
+    "!dist/**/*.map",
+    "manifest.json",
+    "llms.txt",
+    "llms-full.txt",
+    "llms",
+    "guides",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "codegen": "tsx scripts/codegen.ts",
+    "codegen:filters": "tsx scripts/codegen-filters.ts",
+    "codegen:query-filters": "tsx scripts/codegen-query-filters.ts",
+    "codegen:methods": "tsx scripts/codegen-field-methods.ts",
+    "codegen:sweep": "tsx scripts/codegen-sweep.ts",
+    "codegen:replay": "tsx scripts/codegen-replay.ts",
+    "codegen:imports": "tsx scripts/codegen-imports.ts",
+    "codegen:surface": "tsx scripts/codegen-surface.ts",
+    "codegen:themes": "tsx scripts/gen-shadcn-themes.ts",
+    "codegen:fonts": "tsx scripts/gen-shadcn-fonts.ts",
+    "audit:spec-drift": "tsx scripts/spec-drift.ts",
+    "audit:special-required": "tsx scripts/special-required.ts",
+    "audit:engine-drift": "bash .github/scripts/engine-drift.sh",
+    "audit:output-flag": "tsx scripts/audit-output-flag.ts",
+    "audit:decode-coverage": "tsx scripts/audit-decode-coverage.ts",
+    "audit:dts": "npm run build && tsx scripts/audit-dts.ts",
+    "manifest": "tsx scripts/manifest.ts",
+    "codes": "tsx scripts/codes.ts",
+    "changelog": "tsx scripts/changelog.ts",
+    "measure:llms": "tsx scripts/measure-llms.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "e2e:ephemeral": "bash scripts/e2e-ephemeral.sh",
+    "e2e:local-engine": "bash scripts/e2e-local-engine.sh",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run build",
+    "prepack": "node scripts/check-dist.mjs",
+    "release": "npm publish --access public",
+    "release:beta": "npm version prerelease --preid=beta -m \"chore(release): %s\" && npm publish --tag beta --access public",
+    "examples:index": "tsx scripts/gen-examples-index.ts",
+    "examples:check": "npm run examples:index && tsc --noEmit -p examples/sandbox/tsconfig.json",
+    "examples:statements": "tsx scripts/gen-examples.ts",
+    "examples:filters": "tsx scripts/gen-filters.ts",
+    "examples:gen": "tsx scripts/gen-examples.ts && tsx scripts/gen-filters.ts && tsx scripts/gen-examples-index.ts"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "openid-client": "^6.8.4",
+    "proper-lockfile": "^4.1.2"
+  },
+  "peerDependencies": {
+    "esbuild": ">=0.21.0"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "esbuild": "^0.28.1",
+    "eslint": "^9.0.0",
+    "gpt-tokenizer": "^3.4.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5.5.0",
+    "vitest": "^4.1.11"
+  },
+  "overrides": {
+    "esbuild": "^0.28.1"
+  }
+}

package/types/lambda-globals.d.ts

@@ -0,0 +1,129 @@
+/**
+ * The globals a lambda body can reach without an import, declared for the
+ * `lam.file` modules (or any file holding lambda bodies) so they type-check
+ * without hand-written `declare const`s.
+ *
+ * These are GLOBAL declarations: whatever program loads this file sees them
+ * everywhere, and in a program with a frontend its `fetch()` would resolve to
+ * the lambda runtime's response. So load it only in a tsconfig of the lambda
+ * modules' own — a scaffolded project's `xano/lambdas/tsconfig.json` names it in
+ * `types`, and the project tsconfig excludes that directory. Outside a
+ * scaffold, do the same (or `import type {} from "@xano/sdk/lambda-globals"`
+ * from a lambda module checked under its own tsconfig).
+ *
+ * The preloaded libraries are typed `any`: their own typings are not
+ * dependencies of this package. Their names match `LAMBDA_MODULE_GLOBALS`.
+ *
+ * The runtime globals (`crypto`, `Buffer`, `fetch`, `TextEncoder`/`TextDecoder`,
+ * `console`) are declared by merging into the interfaces the DOM lib and
+ * `@types/node` already declare, so the file compiles under `lib: ["ES2022"]`
+ * alone, with `DOM`, and with `DOM` plus `@types/node`. With `@types/node` and
+ * no `DOM` lib, node's own `crypto`/`TextEncoder`/`TextDecoder` declarations
+ * disagree with these (node's global `crypto` is Web Crypto only);
+ * `skipLibCheck: true` accepts them and keeps the lambda runtime's
+ * `createHmac`/`createHash`.
+ */
+export {};
+
+declare global {
+  const _: any;
+  const aws4: any;
+  const axios: any;
+  const cryptojs: any;
+  const DateTime: any;
+  const ethers: any;
+  const fastXmlParser: any;
+  const jose: any;
+  const luxon: any;
+  const mailparser: any;
+  const math: any;
+  const moment: any;
+  const nodemailer: any;
+  const socks: any;
+  const uuid: any;
+  const utils: any;
+
+  /** The byte encodings `Buffer`, `digest()` and `toString()` read and write. */
+  type LambdaEncoding = "utf8" | "utf-8" | "hex" | "base64" | "base64url" | "latin1" | "binary" | "ascii";
+
+  /** Bytes returned by `Buffer` and `digest()`: a `Uint8Array` that prints in an encoding. */
+  interface LambdaBuffer extends Uint8Array {
+    toString(encoding?: LambdaEncoding): string;
+  }
+
+  /** `crypto.createHmac(…)` / `crypto.createHash(…)`: feed with `update`, finish with `digest`. */
+  interface LambdaHash {
+    update(data: string | Uint8Array, encoding?: LambdaEncoding): LambdaHash;
+    digest(): LambdaBuffer;
+    digest(encoding: LambdaEncoding): string;
+  }
+
+  interface Crypto {
+    /** HMAC over `key`: `crypto.createHmac("sha256", secret).update(body).digest("hex")`. */
+    createHmac(algorithm: string, key: string | Uint8Array): LambdaHash;
+    /** A digest: `crypto.createHash("sha256").update(text).digest("hex")`. */
+    createHash(algorithm: string): LambdaHash;
+    randomUUID(): string;
+    getRandomValues<T extends ArrayBufferView>(array: T): T;
+    readonly subtle: SubtleCrypto;
+  }
+  interface SubtleCrypto {
+    digest(algorithm: string | { name: string }, data: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer>;
+    importKey(format: string, keyData: any, algorithm: any, extractable: boolean, keyUsages: string[]): Promise<any>;
+    sign(algorithm: any, key: any, data: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer>;
+    verify(algorithm: any, key: any, signature: ArrayBufferView | ArrayBuffer, data: ArrayBufferView | ArrayBuffer): Promise<boolean>;
+  }
+  var crypto: typeof globalThis extends { onmessage: any; crypto: infer T } ? T : Crypto;
+
+  interface BufferConstructor {
+    from(data: string, encoding?: LambdaEncoding): LambdaBuffer;
+    from(data: ArrayBuffer | ArrayLike<number>): LambdaBuffer;
+    alloc(size: number): LambdaBuffer;
+    concat(list: readonly Uint8Array[]): LambdaBuffer;
+    byteLength(data: string, encoding?: LambdaEncoding): number;
+    isBuffer(value: unknown): boolean;
+  }
+  var Buffer: BufferConstructor;
+
+  interface LambdaHeaders {
+    get(name: string): string | null;
+    has(name: string): boolean;
+    forEach(fn: (value: string, name: string) => void): void;
+  }
+  interface LambdaResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: LambdaHeaders;
+    json(): Promise<any>;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+  }
+  interface LambdaRequestInit {
+    method?: string;
+    headers?: Record<string, string> | [string, string][];
+    body?: string | Uint8Array | ArrayBuffer | null;
+    signal?: any;
+  }
+  function fetch(input: string | { readonly href: string }, init?: LambdaRequestInit): Promise<LambdaResponse>;
+
+  interface TextEncoder {
+    encode(input?: string): Uint8Array;
+  }
+  interface TextDecoder {
+    decode(input?: ArrayBufferView | ArrayBuffer): string;
+  }
+  var TextEncoder: typeof globalThis extends { onmessage: any; TextEncoder: infer T } ? T : { prototype: TextEncoder; new (): TextEncoder };
+  var TextDecoder: typeof globalThis extends { onmessage: any; TextDecoder: infer T } ? T : { prototype: TextDecoder; new (label?: string): TextDecoder };
+
+  /** Routed to the request log. Only these methods exist; calling any other throws. */
+  interface Console {
+    log(...data: any[]): void;
+    error(...data: any[]): void;
+    warn(...data: any[]): void;
+    info(...data: any[]): void;
+    debug(...data: any[]): void;
+    trace(...data: any[]): void;
+  }
+  var console: Console;
+}