@eventmodelers/node-kit 0.0.2

package/templates/realtime-agent/node_modules/@supabase/supabase-js/src/lib/types.ts

@@ -0,0 +1,196 @@
+import { GoTrueClientOptions } from '@supabase/auth-js'
+import { RealtimeClientOptions } from '@supabase/realtime-js'
+import { PostgrestError } from '@supabase/postgrest-js'
+import type { StorageClientOptions } from '@supabase/storage-js'
+import type {
+  GenericSchema,
+  GenericRelationship,
+  GenericTable,
+  GenericUpdatableView,
+  GenericNonUpdatableView,
+  GenericView,
+  GenericFunction,
+} from './rest/types/common/common'
+export type {
+  GenericSchema,
+  GenericRelationship,
+  GenericTable,
+  GenericUpdatableView,
+  GenericNonUpdatableView,
+  GenericView,
+  GenericFunction,
+}
+
+export interface SupabaseAuthClientOptions extends GoTrueClientOptions {}
+
+export type Fetch = typeof fetch
+
+export type SupabaseClientOptions<SchemaName> = {
+  /**
+   * The Postgres schema which your tables belong to. Must be on the list of exposed schemas in Supabase. Defaults to `public`.
+   */
+  db?: {
+    schema?: SchemaName
+    /**
+     * Optional timeout in milliseconds for PostgREST requests.
+     * When set, requests will automatically abort after this duration to prevent indefinite hangs.
+     *
+     * @example With timeout
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { timeout: 30000 } // 30 second timeout
+     * })
+     * ```
+     */
+    timeout?: number
+    /**
+     * Maximum URL length in characters before warnings/errors are triggered.
+     * Defaults to 8000 characters. Used to provide helpful hints when URLs
+     * exceed server limits.
+     *
+     * @example With custom URL length limit
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { urlLengthLimit: 10000 } // Custom limit
+     * })
+     * ```
+     */
+    urlLengthLimit?: number
+  }
+
+  auth?: {
+    /**
+     * Automatically refreshes the token for logged-in users. Defaults to true.
+     */
+    autoRefreshToken?: boolean
+    /**
+     * Optional key name used for storing tokens in local storage.
+     */
+    storageKey?: string
+    /**
+     * Whether to persist a logged-in session to storage. Defaults to true.
+     */
+    persistSession?: boolean
+    /**
+     * Detect a session from the URL. Used for OAuth login callbacks. Defaults to true.
+     *
+     * Can be set to a function to provide custom logic for determining if a URL contains
+     * a Supabase auth callback. The function receives the current URL and parsed parameters,
+     * and should return true if the URL should be processed as a Supabase auth callback.
+     *
+     * This is useful when your app uses other OAuth providers (e.g., Facebook Login) that
+     * also return access_token in the URL fragment, which would otherwise be incorrectly
+     * intercepted by Supabase Auth.
+     *
+     * @example With custom detection logic
+     * ```ts
+     * detectSessionInUrl: (url, params) => {
+     *   // Ignore Facebook OAuth redirects
+     *   if (url.pathname === '/facebook/redirect') return false
+     *   // Use default detection for other URLs
+     *   return Boolean(params.access_token || params.error_description)
+     * }
+     * ```
+     */
+    detectSessionInUrl?: boolean | ((url: URL, params: { [parameter: string]: string }) => boolean)
+    /**
+     * A storage provider. Used to store the logged-in session.
+     */
+    storage?: SupabaseAuthClientOptions['storage']
+    /**
+     * A storage provider to store the user profile separately from the session.
+     * Useful when you need to store the session information in cookies,
+     * without bloating the data with the redundant user object.
+     *
+     * @experimental
+     */
+    userStorage?: SupabaseAuthClientOptions['userStorage']
+    /**
+     * OAuth flow to use - defaults to implicit flow. PKCE is recommended for mobile and server-side applications.
+     */
+    flowType?: SupabaseAuthClientOptions['flowType']
+    /**
+     * If debug messages for authentication client are emitted. Can be used to inspect the behavior of the library.
+     */
+    debug?: SupabaseAuthClientOptions['debug']
+    /**
+     * Provide your own locking mechanism based on the environment. By default no locking is done at this time.
+     *
+     * @experimental
+     */
+    lock?: SupabaseAuthClientOptions['lock']
+    /**
+     * If there is an error with the query, throwOnError will reject the promise by
+     * throwing the error instead of returning it as part of a successful response.
+     */
+    throwOnError?: SupabaseAuthClientOptions['throwOnError']
+    /**
+     * Opt-in flags for experimental features. These APIs may change without
+     * notice and are disabled by default.
+     *
+     * @experimental
+     */
+    experimental?: SupabaseAuthClientOptions['experimental']
+    /**
+     * Maximum time in milliseconds to wait when acquiring the auth lock before
+     * stealing it from the previous holder. See `GoTrueClientOptions.lockAcquireTimeout`
+     * for full semantics (zero fails immediately, negative waits indefinitely).
+     *
+     * @default 5000
+     */
+    lockAcquireTimeout?: SupabaseAuthClientOptions['lockAcquireTimeout']
+    /**
+     * If true, skips automatic initialization in the auth client constructor.
+     * Useful for SSR contexts where initialization timing must be controlled to
+     * prevent race conditions with HTTP response generation.
+     *
+     * @default false
+     */
+    skipAutoInitialize?: SupabaseAuthClientOptions['skipAutoInitialize']
+  }
+  /**
+   * Options passed to the realtime-js instance
+   */
+  realtime?: RealtimeClientOptions
+  storage?: StorageClientOptions
+  global?: {
+    /**
+     * A custom `fetch` implementation.
+     */
+    fetch?: Fetch
+    /**
+     * Optional headers for initializing the client.
+     */
+    headers?: Record<string, string>
+  }
+  /**
+   * Optional function for using a third-party authentication system with
+   * Supabase. The function should return an access token or ID token (JWT) by
+   * obtaining it from the third-party auth SDK. Note that this
+   * function may be called concurrently and many times. Use memoization and
+   * locking techniques if this is not supported by the SDKs.
+   *
+   * When set, the `auth` namespace of the Supabase client cannot be used.
+   * Create another client if you wish to use Supabase Auth and third-party
+   * authentications concurrently in the same application.
+   */
+  accessToken?: () => Promise<string | null>
+}
+
+/**
+ * Helper types for query results.
+ */
+export type QueryResult<T> = T extends PromiseLike<infer U> ? U : never
+export type QueryData<T> = T extends PromiseLike<{ data: infer U }> ? Exclude<U, null> : never
+export type QueryError = PostgrestError
+
+/**
+ * Strips internal Supabase metadata from Database types.
+ * Useful for libraries defining generic constraints on Database types.
+ *
+ * @example Stripping internal Supabase metadata
+ * ```typescript
+ * type CleanDB = DatabaseWithoutInternals<Database>
+ * ```
+ */
+export type DatabaseWithoutInternals<DB> = Omit<DB, '__InternalSupabase'>

package/templates/realtime-agent/node_modules/@supabase/supabase-js/src/lib/version.ts

@@ -0,0 +1,7 @@
+// Generated automatically during releases by scripts/update-version-files.ts
+// This file provides runtime access to the package version for:
+// - HTTP request headers (e.g., X-Client-Info header for API requests)
+// - Debugging and support (identifying which version is running)
+// - Telemetry and logging (version reporting in errors/analytics)
+// - Ensuring build artifacts match the published package version
+export const version = '2.105.4'

package/templates/realtime-agent/node_modules/iceberg-js/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Supabase
+
+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/templates/realtime-agent/node_modules/iceberg-js/README.md

@@ -0,0 +1,439 @@
+# iceberg-js
+
+[![CI](https://github.com/supabase/iceberg-js/actions/workflows/ci.yml/badge.svg)](https://github.com/supabase/iceberg-js/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/iceberg-js.svg)](https://www.npmjs.com/package/iceberg-js)
+[![pkg.pr.new](https://pkg.pr.new/badge/supabase/iceberg-js)](https://pkg.pr.new/~/supabase/iceberg-js)
+
+A small, framework-agnostic JavaScript/TypeScript client for the **Apache Iceberg REST Catalog**.
+
+## Features
+
+- **Generic**: Works with any Iceberg REST Catalog implementation, not tied to any specific vendor
+- **Minimal**: Thin HTTP wrapper over the official REST API, no engine-specific logic
+- **Type-safe**: First-class TypeScript support with strongly-typed request/response models
+- **Fetch-based**: Uses native `fetch` API with support for custom implementations
+- **Universal**: Targets Node 20+ and modern browsers (ES2020)
+- **Catalog-only**: Focused on catalog operations (no data reading/Parquet support in v0.1.0)
+
+## Documentation
+
+📚 **Full API documentation**: [supabase.github.io/iceberg-js](https://supabase.github.io/iceberg-js/)
+
+## Installation
+
+```bash
+npm install iceberg-js
+```
+
+## Quick Start
+
+```typescript
+import { IcebergRestCatalog } from 'iceberg-js'
+
+const catalog = new IcebergRestCatalog({
+  baseUrl: 'https://my-catalog.example.com/iceberg/v1',
+  auth: {
+    type: 'bearer',
+    token: process.env.ICEBERG_TOKEN,
+  },
+})
+
+// Create a namespace
+await catalog.createNamespace({ namespace: ['analytics'] })
+
+// Create a table
+await catalog.createTable(
+  { namespace: ['analytics'] },
+  {
+    name: 'events',
+    schema: {
+      type: 'struct',
+      fields: [
+        { id: 1, name: 'id', type: 'long', required: true },
+        { id: 2, name: 'timestamp', type: 'timestamp', required: true },
+        { id: 3, name: 'user_id', type: 'string', required: false },
+      ],
+      'schema-id': 0,
+      'identifier-field-ids': [1],
+    },
+    'partition-spec': {
+      'spec-id': 0,
+      fields: [],
+    },
+    'write-order': {
+      'order-id': 0,
+      fields: [],
+    },
+    properties: {
+      'write.format.default': 'parquet',
+    },
+  }
+)
+```
+
+## API Reference
+
+### Constructor
+
+#### `new IcebergRestCatalog(options)`
+
+Creates a new catalog client instance.
+
+**Options:**
+
+- `baseUrl` (string, required): Base URL of the REST catalog
+- `auth` (AuthConfig, optional): Authentication configuration
+- `catalogName` (string, optional): Catalog name for multi-catalog servers. When specified, requests are sent to `{baseUrl}/v1/{catalogName}/...`. For example, with `baseUrl: 'https://host.com'` and `catalogName: 'prod'`, requests go to `https://host.com/v1/prod/namespaces`
+- `fetch` (typeof fetch, optional): Custom fetch implementation
+- `accessDelegation` (AccessDelegation[], optional): Access delegation mechanisms to request from the server
+
+**Authentication types:**
+
+```typescript
+// No authentication
+{ type: 'none' }
+
+// Bearer token
+{ type: 'bearer', token: 'your-token' }
+
+// Custom header
+{ type: 'header', name: 'X-Custom-Auth', value: 'secret' }
+
+// Custom function
+{ type: 'custom', getHeaders: async () => ({ 'Authorization': 'Bearer ...' }) }
+```
+
+**Access Delegation:**
+
+Access delegation allows the catalog server to provide temporary credentials or sign requests on your behalf:
+
+```typescript
+import { IcebergRestCatalog } from 'iceberg-js'
+
+const catalog = new IcebergRestCatalog({
+  baseUrl: 'https://catalog.example.com/iceberg/v1',
+  auth: { type: 'bearer', token: 'your-token' },
+  // Request vended credentials for data access
+  accessDelegation: ['vended-credentials'],
+})
+
+// The server may return temporary credentials in the table metadata
+const metadata = await catalog.loadTable({ namespace: ['analytics'], name: 'events' })
+// Use credentials from metadata.config to access table data files
+```
+
+Supported delegation mechanisms:
+
+- `vended-credentials`: Server provides temporary credentials (e.g., AWS STS tokens) for accessing table data
+- `remote-signing`: Server signs data access requests on behalf of the client
+
+### Namespace Operations
+
+#### `listNamespaces(parent?: NamespaceIdentifier): Promise<NamespaceIdentifier[]>`
+
+List all namespaces, optionally under a parent namespace.
+
+```typescript
+const namespaces = await catalog.listNamespaces()
+// [{ namespace: ['default'] }, { namespace: ['analytics'] }]
+
+const children = await catalog.listNamespaces({ namespace: ['analytics'] })
+// [{ namespace: ['analytics', 'prod'] }]
+```
+
+#### `createNamespace(id: NamespaceIdentifier, metadata?: NamespaceMetadata): Promise<void>`
+
+Create a new namespace with optional properties.
+
+```typescript
+await catalog.createNamespace({ namespace: ['analytics'] }, { properties: { owner: 'data-team' } })
+```
+
+#### `dropNamespace(id: NamespaceIdentifier): Promise<void>`
+
+Drop a namespace. The namespace must be empty.
+
+```typescript
+await catalog.dropNamespace({ namespace: ['analytics'] })
+```
+
+#### `loadNamespaceMetadata(id: NamespaceIdentifier): Promise<NamespaceMetadata>`
+
+Load namespace metadata and properties.
+
+```typescript
+const metadata = await catalog.loadNamespaceMetadata({ namespace: ['analytics'] })
+// { properties: { owner: 'data-team', ... } }
+```
+
+### Table Operations
+
+#### `listTables(namespace: NamespaceIdentifier): Promise<TableIdentifier[]>`
+
+List all tables in a namespace.
+
+```typescript
+const tables = await catalog.listTables({ namespace: ['analytics'] })
+// [{ namespace: ['analytics'], name: 'events' }]
+```
+
+#### `createTable(namespace: NamespaceIdentifier, request: CreateTableRequest): Promise<TableMetadata>`
+
+Create a new table.
+
+```typescript
+const metadata = await catalog.createTable(
+  { namespace: ['analytics'] },
+  {
+    name: 'events',
+    schema: {
+      type: 'struct',
+      fields: [
+        { id: 1, name: 'id', type: 'long', required: true },
+        { id: 2, name: 'timestamp', type: 'timestamp', required: true },
+      ],
+      'schema-id': 0,
+    },
+    'partition-spec': {
+      'spec-id': 0,
+      fields: [
+        {
+          source_id: 2,
+          field_id: 1000,
+          name: 'ts_day',
+          transform: 'day',
+        },
+      ],
+    },
+  }
+)
+```
+
+#### `loadTable(id: TableIdentifier): Promise<TableMetadata>`
+
+Load table metadata.
+
+```typescript
+const metadata = await catalog.loadTable({
+  namespace: ['analytics'],
+  name: 'events',
+})
+```
+
+#### `updateTable(id: TableIdentifier, request: UpdateTableRequest): Promise<TableMetadata>`
+
+Update table metadata (schema, partition spec, or properties).
+
+```typescript
+const updated = await catalog.updateTable(
+  { namespace: ['analytics'], name: 'events' },
+  {
+    properties: { 'read.split.target-size': '134217728' },
+  }
+)
+```
+
+#### `dropTable(id: TableIdentifier): Promise<void>`
+
+Drop a table from the catalog.
+
+```typescript
+await catalog.dropTable({ namespace: ['analytics'], name: 'events' })
+```
+
+## Error Handling
+
+All API errors throw an `IcebergError` with details from the server:
+
+```typescript
+import { IcebergError } from 'iceberg-js'
+
+try {
+  await catalog.loadTable({ namespace: ['test'], name: 'missing' })
+} catch (error) {
+  if (error instanceof IcebergError) {
+    console.log(error.status) // 404
+    console.log(error.icebergType) // 'NoSuchTableException'
+    console.log(error.message) // 'Table does not exist'
+  }
+}
+```
+
+## TypeScript Types
+
+The library exports all relevant types:
+
+```typescript
+import type {
+  NamespaceIdentifier,
+  TableIdentifier,
+  TableSchema,
+  TableField,
+  IcebergType,
+  PartitionSpec,
+  SortOrder,
+  CreateTableRequest,
+  TableMetadata,
+  AuthConfig,
+  AccessDelegation,
+} from 'iceberg-js'
+```
+
+## Supported Iceberg Types
+
+The following Iceberg primitive types are supported:
+
+- `boolean`, `int`, `long`, `float`, `double`
+- `string`, `uuid`, `binary`
+- `date`, `time`, `timestamp`, `timestamptz`
+- `decimal(precision, scale)`, `fixed(length)`
+
+## Compatibility
+
+This package is built to work in **all** Node.js and JavaScript environments:
+
+| Environment         | Module System        | Import Method                           | Status                |
+| ------------------- | -------------------- | --------------------------------------- | --------------------- |
+| Node.js ESM         | `"type": "module"`   | `import { ... } from 'iceberg-js'`      | ✅ Fully supported    |
+| Node.js CommonJS    | Default              | `const { ... } = require('iceberg-js')` | ✅ Fully supported    |
+| TypeScript ESM      | `module: "ESNext"`   | `import { ... } from 'iceberg-js'`      | ✅ Full type support  |
+| TypeScript CommonJS | `module: "CommonJS"` | `import { ... } from 'iceberg-js'`      | ✅ Full type support  |
+| Bundlers            | Any                  | Webpack, Vite, esbuild, Rollup, etc.    | ✅ Auto-detected      |
+| Browsers            | ESM                  | `<script type="module">`                | ✅ Modern browsers    |
+| Deno                | ESM                  | `import` from npm:                      | ✅ With npm specifier |
+
+**Package exports:**
+
+- ESM: `dist/index.mjs` with `dist/index.d.ts`
+- CommonJS: `dist/index.cjs` with `dist/index.d.cts`
+- Proper `exports` field for Node.js 12+ module resolution
+
+All scenarios are tested in CI on Node.js 20 and 22.
+
+## Browser Usage
+
+The library works in modern browsers that support native `fetch`:
+
+```typescript
+import { IcebergRestCatalog } from 'iceberg-js'
+
+const catalog = new IcebergRestCatalog({
+  baseUrl: 'https://public-catalog.example.com/iceberg/v1',
+  auth: { type: 'none' },
+})
+
+const namespaces = await catalog.listNamespaces()
+```
+
+## Node.js Usage
+
+Node.js 20+ includes native `fetch` support. For older versions, provide a custom fetch implementation:
+
+```typescript
+import { IcebergRestCatalog } from 'iceberg-js'
+import fetch from 'node-fetch'
+
+const catalog = new IcebergRestCatalog({
+  baseUrl: 'https://catalog.example.com/iceberg/v1',
+  auth: { type: 'bearer', token: 'token' },
+  fetch: fetch as any,
+})
+```
+
+## Limitations (v0.1.0)
+
+This is a catalog client only. The following are **not supported**:
+
+- Reading table data (scanning Parquet files)
+- Writing data to tables
+- Advanced table operations (commits, snapshots, time travel)
+- Views support
+- Multi-table transactions
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the library
+pnpm run build
+
+# Run unit tests
+pnpm test
+
+# Run integration tests (requires Docker)
+pnpm test:integration
+
+# Run integration tests with cleanup (for CI)
+pnpm test:integration:ci
+
+# Run compatibility tests (all module systems)
+pnpm test:compatibility
+
+# Format code
+pnpm run format
+
+# Lint and test
+pnpm run check
+```
+
+### Testing with Docker
+
+Integration tests run against a local Iceberg REST Catalog in Docker. See [TESTING-DOCKER.md](./test/integration/TESTING-DOCKER.md) for details.
+
+```bash
+# Start Docker services and run integration tests
+pnpm test:integration
+
+# Or manually
+docker compose up -d
+npx tsx test/integration/test-local-catalog.ts
+docker compose down -v
+```
+
+### Compatibility Testing
+
+The `test:compatibility` script verifies the package works correctly in all JavaScript/TypeScript environments:
+
+- **Pure JavaScript ESM** - Projects with `"type": "module"`
+- **Pure JavaScript CommonJS** - Traditional Node.js projects
+- **TypeScript ESM** - TypeScript with `module: "ESNext"`
+- **TypeScript CommonJS** - TypeScript with `module: "CommonJS"`
+
+These tests ensure proper module resolution, type definitions, and runtime behavior across all supported environments. See [test/compatibility/README.md](./test/compatibility/README.md) for more details.
+
+## License
+
+MIT
+
+## Releases
+
+This project uses [release-please](https://github.com/googleapis/release-please) for automated releases. Here's how it works:
+
+1. **Commit with conventional commits**: Use [Conventional Commits](https://www.conventionalcommits.org/) format for your commits:
+   - `feat:` for new features (minor version bump)
+   - `fix:` for bug fixes (patch version bump)
+   - `feat!:` or `BREAKING CHANGE:` for breaking changes (major version bump)
+   - `chore:`, `docs:`, `test:`, etc. for non-release commits
+
+2. **Release PR is created automatically**: When you push to `main`, release-please creates/updates a release PR with:
+   - Version bump in `package.json`
+   - Updated `CHANGELOG.md`
+   - Release notes
+
+3. **Merge the release PR**: When you're ready to release, merge the PR. This will:
+   - Create a GitHub release and git tag
+   - Automatically publish to npm with provenance (using trusted publishing, no secrets needed)
+
+**Example commits:**
+
+```bash
+git commit -m "feat: add support for view operations"
+git commit -m "fix: handle empty namespace list correctly"
+git commit -m "feat!: change auth config structure"
+```
+
+## Contributing
+
+Contributions are welcome! This library aims to be a minimal, generic client for the Iceberg REST Catalog API.