@pipelab/shared 2.0.1-beta.20

package/src/supabase.ts

@@ -0,0 +1,28 @@
+import { createClient } from "@supabase/supabase-js";
+import { Database } from "./database.types";
+
+const getSupabaseConfig = () => {
+  const url = process.env.SUPABASE_URL || "";
+  const anonKey = process.env.SUPABASE_ANON_KEY || "";
+  return { url, anonKey };
+};
+
+export const isSupabaseAvailable = () => {
+  const { url, anonKey } = getSupabaseConfig();
+  const available = !!(url && anonKey);
+
+  return available;
+};
+
+export const supabase = (options?: any) => {
+  const { url, anonKey } = getSupabaseConfig();
+  if (!url || !anonKey) {
+    if (process.env.NODE_ENV !== "test") {
+      console.warn(
+        "Supabase environment variables are not configured. Supabase will not be available.",
+      );
+    }
+    return null;
+  }
+  return createClient<Database>(url, anonKey, options);
+};

package/src/tests/helpers.ts

@@ -0,0 +1,5 @@
+import { vi } from "vitest";
+
+export const browserWindow = {
+  setProgressBar: vi.fn(),
+} satisfies Partial<Electron.BrowserWindow> as unknown as Electron.BrowserWindow;

package/src/types.ts

@@ -0,0 +1,3 @@
+export type NodeId = string; // keyof typeof nodes
+
+export type Context = Record<string, unknown>;

package/src/utils.ts

@@ -0,0 +1,3 @@
+export const foo = "bar";
+
+export type WithId<T> = T extends string | number ? never : T & { id: string };

package/src/validation.ts

@@ -0,0 +1,16 @@
+import { InputDefinition } from "./plugins/definitions";
+
+export const isRequired = (param: InputDefinition) => {
+  return param.required === true;
+};
+
+export const isRenderer = () => {
+  // running in a web browser
+  if (typeof process === "undefined") return true;
+
+  // node-integration is disabled
+  if (!process) return true;
+
+  // @ts-expect-error
+  return process.browser === true || process.title === "browser";
+};

package/src/variables.ts

@@ -0,0 +1,27 @@
+import { CreateQuickJSFn } from "./quickjs";
+
+export interface VariableBase {
+  value: string;
+  id: string;
+  name: string;
+  description: string;
+}
+
+export type Variable = VariableBase;
+
+export const variableToFormattedVariable = async (
+  vm: Awaited<CreateQuickJSFn>,
+  variables: Variable[],
+) => {
+  const result: Record<string, string> = {};
+  for (const variable of variables) {
+    console.log("variable.value", variable.value);
+    const variableResult = await vm.run(variable.value, {
+      params: {},
+    });
+
+    result[variable.id] = variableResult;
+    // result[variable.id] = variable.value
+  }
+  return result;
+};

package/src/wasm.d.ts

@@ -0,0 +1,9 @@
+declare module "@jitl/quickjs-wasmfile-release-sync/wasm" {
+  const wasm: string;
+  export default wasm;
+}
+
+declare module "@jitl/quickjs-wasmfile-release-sync/wasm?url" {
+  const wasm: string;
+  export default wasm;
+}

package/src/websocket.types.ts

@@ -0,0 +1,186 @@
+import { Channels, Data, Events, End, IpcMessage, RequestId } from "./apis";
+import { WebSocket as WSWebSocket } from "ws";
+
+// WebSocket connection states
+export type WebSocketConnectionState =
+  | "connecting"
+  | "connected"
+  | "disconnected"
+  | "error"
+  | "reconnecting";
+
+// WebSocket server types
+export interface WebSocketServerConfig {
+  port?: number;
+  host?: string;
+  maxReconnectAttempts?: number;
+  reconnectDelay?: number;
+}
+
+export interface WebSocketServerEvents {
+  connection: (ws: WSWebSocket, request: IncomingMessage) => void;
+  message: (ws: WSWebSocket, data: Buffer) => void;
+  close: (ws: WSWebSocket) => void;
+  error: (ws: WSWebSocket, error: Error) => void;
+}
+
+// WebSocket client types
+export interface WebSocketClientConfig {
+  url?: string;
+  maxReconnectAttempts?: number;
+  reconnectDelay?: number;
+  timeout?: number;
+}
+
+export interface WebSocketClientEvents {
+  open: () => void;
+  message: (event: MessageEvent) => void;
+  close: (event: CloseEvent) => void;
+  error: (error: Event) => void;
+}
+
+// Unified WebSocket event types
+export interface WebSocketEvent {
+  sender: string;
+  timestamp?: number;
+}
+
+// WebSocket message types
+export interface WebSocketRequestMessage {
+  channel: Channels;
+  requestId: RequestId;
+  data: any;
+}
+
+export interface WebSocketResponseMessage {
+  type: "response";
+  requestId: RequestId;
+  events: Events<any>;
+}
+
+export interface WebSocketErrorMessage {
+  type: "error";
+  requestId: RequestId;
+  error: string;
+  code?: string;
+}
+
+export type WebSocketMessage =
+  | WebSocketRequestMessage
+  | WebSocketResponseMessage
+  | WebSocketErrorMessage;
+
+// WebSocket connection info
+export interface WebSocketConnectionInfo {
+  id: string;
+  state: WebSocketConnectionState;
+  url: string;
+  connectedAt?: Date;
+  lastActivity?: Date;
+}
+
+export interface Agent {
+  id: string;
+  name: string;
+  isSelf: boolean;
+  connectedAt?: number;
+}
+
+// Handler function types
+export type WebSocketHandler<KEY extends Channels> = (
+  event: WebSocketEvent,
+  data: { value: Data<KEY>; send: WebSocketSendFunction<KEY> },
+) => Promise<void>;
+
+export type WebSocketSendFunction<KEY extends Channels> = (events: Events<KEY>) => Promise<void>;
+
+// WebSocket listener types
+export type WebSocketListener<KEY extends Channels> = (event: Events<KEY>) => Promise<void>;
+
+// WebSocket API interface
+export interface WebSocketAPI {
+  execute: <KEY extends Channels>(
+    channel: KEY,
+    data?: Data<KEY>,
+    listener?: WebSocketListener<KEY>,
+  ) => Promise<End<KEY>>;
+  send: <KEY extends Channels>(channel: KEY, data?: Data<KEY>) => Promise<End<KEY>>;
+  on: <KEY extends Channels>(
+    channel: KEY,
+    listener: (event: WebSocketEvent, data: Events<KEY>) => void,
+  ) => () => void;
+  isConnected: () => boolean;
+  disconnect: () => void;
+}
+
+// WebSocket manager interface
+export interface WebSocketManager {
+  connect: (url?: string) => Promise<void>;
+  disconnect: () => void;
+  send: <KEY extends Channels>(channel: KEY, data?: Data<KEY>) => Promise<End<KEY>>;
+  isConnected: () => boolean;
+  getConnectionState: () => WebSocketConnectionState;
+  onStateChange: (callback: (state: WebSocketConnectionState) => void) => () => void;
+}
+
+// Error types
+export class WebSocketError extends Error {
+  constructor(
+    message: string,
+    public code?: string,
+    public requestId?: RequestId,
+  ) {
+    super(message);
+    this.name = "WebSocketError";
+  }
+}
+
+export class WebSocketConnectionError extends WebSocketError {
+  constructor(
+    message: string,
+    public url?: string,
+  ) {
+    super(message);
+    this.name = "WebSocketConnectionError";
+  }
+}
+
+export class WebSocketTimeoutError extends WebSocketError {
+  constructor(
+    message: string,
+    public timeout: number,
+    requestId?: RequestId,
+  ) {
+    super(message);
+    this.name = "WebSocketTimeoutError";
+  }
+}
+
+// Type guards
+export const isWebSocketRequestMessage = (message: any): message is WebSocketRequestMessage => {
+  return message && typeof message.channel === "string" && message.requestId;
+};
+
+export const isWebSocketResponseMessage = (message: any): message is WebSocketResponseMessage => {
+  return message && message.type === "response" && message.requestId && message.events;
+};
+
+export const isWebSocketErrorMessage = (message: any): message is WebSocketErrorMessage => {
+  return message && message.type === "error" && message.requestId && message.error;
+};
+
+// Utility types for better type inference
+export type WebSocketMessageType<T extends Channels> = {
+  channel: T;
+  requestId: RequestId;
+  data: Data<T>;
+};
+
+export type WebSocketResponseType<T extends Channels> = {
+  type: "response";
+  requestId: RequestId;
+  events: Events<T>;
+};
+
+// Import for Node.js HTTP server
+import { IncomingMessage } from "http";

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig/commonjs.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": true,
+    "outDir": "dist",
+    "baseUrl": ".",
+    "typeRoots": ["./src"],
+    "types": ["global.d.ts", "wasm.d.ts"]
+  },
+  "include": ["src/**/*", "tests/**/*", "*.ts", "src/**/*.json"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../migration" }]
+}