@eventmodelers/node-kit 0.0.2

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

@@ -0,0 +1,106 @@
+import SupabaseClient from './SupabaseClient'
+import type { SupabaseClientOptions } from './lib/types'
+
+export * from '@supabase/auth-js'
+export type { User as AuthUser, Session as AuthSession } from '@supabase/auth-js'
+export type {
+  PostgrestResponse,
+  PostgrestSingleResponse,
+  PostgrestMaybeSingleResponse,
+  PostgrestBuilder,
+  PostgrestFilterBuilder,
+  PostgrestTransformBuilder,
+  PostgrestQueryBuilder,
+} from '@supabase/postgrest-js'
+export { PostgrestError } from '@supabase/postgrest-js'
+export { StorageApiError } from '@supabase/storage-js'
+export type { FunctionInvokeOptions } from '@supabase/functions-js'
+export {
+  FunctionsHttpError,
+  FunctionsFetchError,
+  FunctionsRelayError,
+  FunctionsError,
+  FunctionRegion,
+} from '@supabase/functions-js'
+export * from '@supabase/realtime-js'
+export { default as SupabaseClient } from './SupabaseClient'
+export type {
+  SupabaseClientOptions,
+  QueryResult,
+  QueryData,
+  QueryError,
+  DatabaseWithoutInternals,
+} from './lib/types'
+
+/**
+ * Creates a new Supabase Client.
+ *
+ * @example Creating a Supabase client
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+ * const { data, error } = await supabase.from('profiles').select('*')
+ * ```
+ */
+export const createClient = <
+  Database = any,
+  SchemaNameOrClientOptions extends
+    | (string & keyof Omit<Database, '__InternalSupabase'>)
+    | { PostgrestVersion: string } = 'public' extends keyof Omit<Database, '__InternalSupabase'>
+    ? 'public'
+    : string & keyof Omit<Database, '__InternalSupabase'>,
+  SchemaName extends string &
+    keyof Omit<Database, '__InternalSupabase'> = SchemaNameOrClientOptions extends string &
+    keyof Omit<Database, '__InternalSupabase'>
+    ? SchemaNameOrClientOptions
+    : 'public' extends keyof Omit<Database, '__InternalSupabase'>
+      ? 'public'
+      : string & keyof Omit<Omit<Database, '__InternalSupabase'>, '__InternalSupabase'>,
+>(
+  supabaseUrl: string,
+  supabaseKey: string,
+  options?: SupabaseClientOptions<SchemaName>
+): SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName> => {
+  return new SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName>(
+    supabaseUrl,
+    supabaseKey,
+    options
+  )
+}
+
+// Check for Node.js <= 18 deprecation
+function shouldShowDeprecationWarning(): boolean {
+  // Skip in browser environments
+  if (typeof window !== 'undefined') {
+    return false
+  }
+
+  // Skip if process is not available (e.g., Edge Runtime)
+  // Use dynamic property access to avoid Next.js Edge Runtime static analysis warnings
+  const _process = (globalThis as any)['process']
+  if (!_process) {
+    return false
+  }
+
+  const processVersion = _process['version']
+  if (processVersion === undefined || processVersion === null) {
+    return false
+  }
+
+  const versionMatch = processVersion.match(/^v(\d+)\./)
+  if (!versionMatch) {
+    return false
+  }
+
+  const majorVersion = parseInt(versionMatch[1], 10)
+  return majorVersion <= 18
+}
+
+if (shouldShowDeprecationWarning()) {
+  console.warn(
+    `⚠️  Node.js 18 and below are deprecated and will no longer be supported in future versions of @supabase/supabase-js. ` +
+      `Please upgrade to Node.js 20 or later. ` +
+      `For more information, visit: https://github.com/orgs/supabase/discussions/37217`
+  )
+}

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

@@ -0,0 +1,8 @@
+import { AuthClient } from '@supabase/auth-js'
+import { SupabaseAuthClientOptions } from './types'
+
+export class SupabaseAuthClient extends AuthClient {
+  constructor(options: SupabaseAuthClientOptions) {
+    super(options)
+  }
+}

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

@@ -0,0 +1,35 @@
+// constants.ts
+import { RealtimeClientOptions } from '@supabase/realtime-js'
+import { SupabaseAuthClientOptions } from './types'
+import { version } from './version'
+
+let JS_ENV = ''
+// @ts-ignore
+if (typeof Deno !== 'undefined') {
+  JS_ENV = 'deno'
+} else if (typeof document !== 'undefined') {
+  JS_ENV = 'web'
+} else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+  JS_ENV = 'react-native'
+} else {
+  JS_ENV = 'node'
+}
+
+export const DEFAULT_HEADERS = { 'X-Client-Info': `supabase-js-${JS_ENV}/${version}` }
+
+export const DEFAULT_GLOBAL_OPTIONS = {
+  headers: DEFAULT_HEADERS,
+}
+
+export const DEFAULT_DB_OPTIONS = {
+  schema: 'public',
+}
+
+export const DEFAULT_AUTH_OPTIONS: SupabaseAuthClientOptions = {
+  autoRefreshToken: true,
+  persistSession: true,
+  detectSessionInUrl: true,
+  flowType: 'implicit',
+}
+
+export const DEFAULT_REALTIME_OPTIONS: RealtimeClientOptions = {}

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

@@ -0,0 +1,36 @@
+type Fetch = typeof fetch
+
+export const resolveFetch = (customFetch?: Fetch): Fetch => {
+  if (customFetch) {
+    return (...args: Parameters<Fetch>) => customFetch(...args)
+  }
+  return (...args: Parameters<Fetch>) => fetch(...args)
+}
+
+export const resolveHeadersConstructor = () => {
+  return Headers
+}
+
+export const fetchWithAuth = (
+  supabaseKey: string,
+  getAccessToken: () => Promise<string | null>,
+  customFetch?: Fetch
+): Fetch => {
+  const fetch = resolveFetch(customFetch)
+  const HeadersConstructor = resolveHeadersConstructor()
+
+  return async (input, init) => {
+    const accessToken = (await getAccessToken()) ?? supabaseKey
+    let headers = new HeadersConstructor(init?.headers)
+
+    if (!headers.has('apikey')) {
+      headers.set('apikey', supabaseKey)
+    }
+
+    if (!headers.has('Authorization')) {
+      headers.set('Authorization', `Bearer ${accessToken}`)
+    }
+
+    return fetch(input, { ...init, headers })
+  }
+}

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

@@ -0,0 +1,98 @@
+// helpers.ts
+import { SupabaseClientOptions } from './types'
+
+export function uuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = (Math.random() * 16) | 0,
+      v = c == 'x' ? r : (r & 0x3) | 0x8
+    return v.toString(16)
+  })
+}
+
+export function ensureTrailingSlash(url: string): string {
+  return url.endsWith('/') ? url : url + '/'
+}
+
+export const isBrowser = () => typeof window !== 'undefined'
+
+export function applySettingDefaults<
+  Database = any,
+  SchemaName extends string & keyof Database = 'public' extends keyof Database
+    ? 'public'
+    : string & keyof Database,
+>(
+  options: SupabaseClientOptions<SchemaName>,
+  defaults: SupabaseClientOptions<any>
+): Required<SupabaseClientOptions<SchemaName>> {
+  const {
+    db: dbOptions,
+    auth: authOptions,
+    realtime: realtimeOptions,
+    global: globalOptions,
+  } = options
+  const {
+    db: DEFAULT_DB_OPTIONS,
+    auth: DEFAULT_AUTH_OPTIONS,
+    realtime: DEFAULT_REALTIME_OPTIONS,
+    global: DEFAULT_GLOBAL_OPTIONS,
+  } = defaults
+
+  const result: Required<SupabaseClientOptions<SchemaName>> = {
+    db: {
+      ...DEFAULT_DB_OPTIONS,
+      ...dbOptions,
+    },
+    auth: {
+      ...DEFAULT_AUTH_OPTIONS,
+      ...authOptions,
+    },
+    realtime: {
+      ...DEFAULT_REALTIME_OPTIONS,
+      ...realtimeOptions,
+    },
+    storage: {},
+    global: {
+      ...DEFAULT_GLOBAL_OPTIONS,
+      ...globalOptions,
+      headers: {
+        ...(DEFAULT_GLOBAL_OPTIONS?.headers ?? {}),
+        ...(globalOptions?.headers ?? {}),
+      },
+    },
+    accessToken: async () => '',
+  }
+
+  if (options.accessToken) {
+    result.accessToken = options.accessToken
+  } else {
+    // hack around Required<>
+    delete (result as any).accessToken
+  }
+
+  return result
+}
+
+/**
+ * Validates a Supabase client URL
+ *
+ * @param {string} supabaseUrl - The Supabase client URL string.
+ * @returns {URL} - The validated base URL.
+ * @throws {Error}
+ */
+export function validateSupabaseUrl(supabaseUrl: string): URL {
+  const trimmedUrl = supabaseUrl?.trim()
+
+  if (!trimmedUrl) {
+    throw new Error('supabaseUrl is required.')
+  }
+
+  if (!trimmedUrl.match(/^https?:\/\//i)) {
+    throw new Error('Invalid supabaseUrl: Must be a valid HTTP or HTTPS URL.')
+  }
+
+  try {
+    return new URL(ensureTrailingSlash(trimmedUrl))
+  } catch {
+    throw Error('Invalid supabaseUrl: Provided URL is malformed.')
+  }
+}

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

@@ -0,0 +1,93 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * This file is automatically synchronized from @supabase/postgrest-js
+ * Source: packages/core/postgrest-js/src/types/common/
+ *
+ * To update this file, modify the source in postgrest-js and run:
+ *   npm run codegen
+ */
+
+// Types that are shared between supabase-js and postgrest-js
+
+export type Fetch = typeof fetch
+
+/**
+ * Default number of retry attempts.
+ */
+export const DEFAULT_MAX_RETRIES = 3
+
+/**
+ * Default exponential backoff delay function.
+ * Delays: 1s, 2s, 4s, 8s, ... (max 30s)
+ *
+ * @param attemptIndex - Zero-based index of the retry attempt
+ * @returns Delay in milliseconds before the next retry
+ */
+export const getRetryDelay = (attemptIndex: number): number =>
+  Math.min(1000 * 2 ** attemptIndex, 30000)
+
+/**
+ * Status codes that are safe to retry.
+ * 520 = Cloudflare timeout/connection errors (transient)
+ * 503 = PostgREST schema cache not yet loaded (transient, signals retry via Retry-After header)
+ */
+export const RETRYABLE_STATUS_CODES = [520, 503] as const
+
+/**
+ * HTTP methods that are safe to retry (idempotent operations).
+ */
+export const RETRYABLE_METHODS = ['GET', 'HEAD', 'OPTIONS'] as const
+
+export type GenericRelationship = {
+  foreignKeyName: string
+  columns: string[]
+  isOneToOne?: boolean
+  referencedRelation: string
+  referencedColumns: string[]
+}
+
+export type GenericTable = {
+  Row: Record<string, unknown>
+  Insert: Record<string, unknown>
+  Update: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericUpdatableView = {
+  Row: Record<string, unknown>
+  Insert: Record<string, unknown>
+  Update: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericNonUpdatableView = {
+  Row: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericView = GenericUpdatableView | GenericNonUpdatableView
+
+export type GenericSetofOption = {
+  isSetofReturn?: boolean | undefined
+  isOneToOne?: boolean | undefined
+  isNotNullable?: boolean | undefined
+  to: string
+  from: string
+}
+
+export type GenericFunction = {
+  Args: Record<string, unknown> | never
+  Returns: unknown
+  SetofOptions?: GenericSetofOption
+}
+
+export type GenericSchema = {
+  Tables: Record<string, GenericTable>
+  Views: Record<string, GenericView>
+  Functions: Record<string, GenericFunction>
+}
+
+export type ClientServerOptions = {
+  PostgrestVersion?: string
+}

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

@@ -0,0 +1,158 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * This file is automatically synchronized from @supabase/postgrest-js
+ * Source: packages/core/postgrest-js/src/types/common/
+ *
+ * To update this file, modify the source in postgrest-js and run:
+ *   npm run codegen
+ */
+
+import type { GenericFunction, GenericSchema, GenericSetofOption } from './common'
+
+// Functions matching utils
+type IsMatchingArgs<
+  FnArgs extends GenericFunction['Args'],
+  PassedArgs extends GenericFunction['Args'],
+> = [FnArgs] extends [Record<PropertyKey, never>]
+  ? PassedArgs extends Record<PropertyKey, never>
+    ? true
+    : false
+  : keyof PassedArgs extends keyof FnArgs
+    ? PassedArgs extends FnArgs
+      ? true
+      : false
+    : false
+
+type MatchingFunctionArgs<
+  Fn extends GenericFunction,
+  Args extends GenericFunction['Args'],
+> = Fn extends { Args: infer A extends GenericFunction['Args'] }
+  ? IsMatchingArgs<A, Args> extends true
+    ? Fn
+    : never
+  : false
+
+type FindMatchingFunctionByArgs<
+  FnUnion,
+  Args extends GenericFunction['Args'],
+> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false
+
+// Types for working with database schemas
+type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>
+
+// Utility types for working with unions
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+  ? I
+  : never
+
+type LastOf<T> =
+  UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never
+
+type IsAny<T> = 0 extends 1 & T ? true : false
+
+type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false
+
+type ExtractExactFunction<Fns, Args> = Fns extends infer F
+  ? F extends GenericFunction
+    ? ExactMatch<F['Args'], Args> extends true
+      ? F
+      : never
+    : never
+  : never
+
+type IsNever<T> = [T] extends [never] ? true : false
+
+type RpcFunctionNotFound<FnName> = {
+  Row: any
+  Result: {
+    error: true
+  } & "Couldn't infer function definition matching provided arguments"
+  RelationName: FnName
+  Relationships: null
+}
+
+type CrossSchemaError<TableRef extends string> = {
+  error: true
+} & `Function returns SETOF from a different schema ('${TableRef}'). Use .overrideTypes<YourReturnType>() to specify the return type explicitly.`
+
+export type GetRpcFunctionFilterBuilderByArgs<
+  Schema extends GenericSchema,
+  FnName extends string & keyof Schema['Functions'],
+  Args,
+> = {
+  0: Schema['Functions'][FnName]
+  // If the Args is exactly never (function call without any params)
+  1: IsAny<Schema> extends true
+    ? any
+    : IsNever<Args> extends true
+      ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
+        // we fallback to the last function definition matched by name
+        IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true
+        ? LastOf<Schema['Functions'][FnName]>
+        : ExtractExactFunction<Schema['Functions'][FnName], Args>
+      : Args extends Record<PropertyKey, never>
+        ? LastOf<Schema['Functions'][FnName]>
+        : // Otherwise, we attempt to match with one of the function definition in the union based
+          // on the function arguments provided
+          Args extends GenericFunction['Args']
+          ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
+            // we fallback to the last function definition matched by name
+            IsNever<
+              LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
+            > extends true
+            ? LastOf<Schema['Functions'][FnName]>
+            : // Otherwise, we use the arguments based function definition narrowing to get the right value
+              LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
+          : // If we can't find a matching function by args, we try to find one by function name
+            ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction
+            ? ExtractExactFunction<Schema['Functions'][FnName], Args>
+            : any
+}[1] extends infer Fn
+  ? // If we are dealing with an non-typed client everything is any
+    IsAny<Fn> extends true
+    ? { Row: any; Result: any; RelationName: FnName; Relationships: null }
+    : // Otherwise, we use the arguments based function definition narrowing to get the right value
+      Fn extends GenericFunction
+      ? {
+          Row: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to'] extends keyof TablesAndViews<Schema>
+              ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row']
+              : // Cross-schema fallback: use Returns type when table is not in current schema
+                Fn['Returns'] extends any[]
+                ? Fn['Returns'][number] extends Record<string, unknown>
+                  ? Fn['Returns'][number]
+                  : CrossSchemaError<Fn['SetofOptions']['to'] & string>
+                : Fn['Returns'] extends Record<string, unknown>
+                  ? Fn['Returns']
+                  : CrossSchemaError<Fn['SetofOptions']['to'] & string>
+            : Fn['Returns'] extends any[]
+              ? Fn['Returns'][number] extends Record<string, unknown>
+                ? Fn['Returns'][number]
+                : never
+              : Fn['Returns'] extends Record<string, unknown>
+                ? Fn['Returns']
+                : never
+          Result: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['isSetofReturn'] extends true
+              ? Fn['SetofOptions']['isOneToOne'] extends true
+                ? Fn['Returns'][]
+                : Fn['Returns']
+              : Fn['Returns']
+            : Fn['Returns']
+          RelationName: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to']
+            : FnName
+          Relationships: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to'] extends keyof Schema['Tables']
+              ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships']
+              : Fn['SetofOptions']['to'] extends keyof Schema['Views']
+                ? Schema['Views'][Fn['SetofOptions']['to']]['Relationships']
+                : null
+            : null
+        }
+      : // If we failed to find the function by argument, we still pass with any but also add an overridable
+        Fn extends false
+        ? RpcFunctionNotFound<FnName>
+        : RpcFunctionNotFound<FnName>
+  : RpcFunctionNotFound<FnName>