@gadmin2n/schematics 0.0.135 → 0.0.137

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "gadmin-workflow-worker",
-  "version": "1.0.0",
-  "private": true,
-  "scripts": {
-    "build": "tsc",
-    "dev": "ts-node src/index.ts",
-    "start": "node dist/index.js",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "dependencies": {
-    "@temporalio/activity": "^1.11.6",
-    "@temporalio/client": "^1.11.6",
-    "@temporalio/worker": "^1.11.6",
-    "@temporalio/workflow": "^1.11.6",
-    "axios": "^1.7.9",
-    "dotenv": "^16.4.7",
-    "pg": "^8.16.3"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@types/pg": "^8.11.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.7.0",
-    "vitest": "^3.1.0"
-  }
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/code-execute.ts

@@ -1,51 +0,0 @@
-export interface CodeExecuteInput {
-  script: string;
-  mode?: 'runOnceForAll' | 'runOnceForEach';
-  timeout?: number;
-  data?: any;
-  items?: any[];
-}
-
-export interface CodeExecuteOutput {
-  result: any;
-}
-
-/**
- * Execute custom JavaScript code in a sandboxed environment.
- * Uses Node.js vm module for basic isolation.
- * For production, consider isolated-vm for stronger sandboxing.
- */
-export async function codeExecute(input: CodeExecuteInput): Promise<CodeExecuteOutput> {
-  const { script, mode = 'runOnceForAll', timeout = 5000, data, items } = input;
-  const vm = await import('vm');
-
-  if (mode === 'runOnceForEach' && Array.isArray(items)) {
-    const results: any[] = [];
-    for (const item of items) {
-      const sandbox = {
-        item,
-        data,
-        console: { log: () => {} },
-        result: undefined as any,
-      };
-      const context = vm.createContext(sandbox);
-      const wrappedScript = new vm.Script(`result = (function() { ${script} })()`);
-      wrappedScript.runInContext(context, { timeout });
-      results.push(sandbox.result);
-    }
-    return { result: results };
-  }
-
-  // runOnceForAll
-  const sandbox = {
-    data,
-    items: items || [],
-    console: { log: () => {} },
-    result: undefined as any,
-  };
-  const context = vm.createContext(sandbox);
-  const wrappedScript = new vm.Script(`result = (function() { ${script} })()`);
-  wrappedScript.runInContext(context, { timeout });
-
-  return { result: sandbox.result };
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/db-execute.ts

@@ -1,85 +0,0 @@
-import { Pool } from 'pg';
-import { config } from '../config';
-
-const pool = new Pool({ connectionString: config.database.url });
-
-export interface DbExecuteInput {
-  operation: 'insert' | 'update' | 'delete' | 'raw';
-  table?: string;
-  data?: Record<string, any>;
-  where?: string;
-  rawSql?: string;
-  params?: any[];
-  datasource?: string;
-  timeout?: number;
-}
-
-export interface DbExecuteOutput {
-  affectedRows: number;
-  insertedId?: string;
-}
-
-/**
- * Execute a database write operation (INSERT/UPDATE/DELETE).
- */
-export async function dbExecute(input: DbExecuteInput): Promise<DbExecuteOutput> {
-  const client = await pool.connect();
-  try {
-    if (input.timeout) {
-      await client.query(`SET statement_timeout = ${input.timeout}`);
-    }
-
-    let query: string;
-    let params: any[] = [];
-
-    switch (input.operation) {
-      case 'raw':
-        query = input.rawSql || '';
-        params = input.params || [];
-        break;
-
-      case 'insert': {
-        if (!input.table || !input.data) throw new Error('table and data required for insert');
-        const keys = Object.keys(input.data);
-        const values = Object.values(input.data);
-        const placeholders = keys.map((_, i) => `$${i + 1}`);
-        query = `INSERT INTO ${input.table} (${keys.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING id`;
-        params = values;
-        break;
-      }
-
-      case 'update': {
-        if (!input.table || !input.data) throw new Error('table and data required for update');
-        const entries = Object.entries(input.data);
-        const sets = entries.map(([k], i) => `${k} = $${i + 1}`);
-        params = entries.map(([, v]) => v);
-        query = `UPDATE ${input.table} SET ${sets.join(', ')}`;
-        if (input.where) {
-          query += ` WHERE ${input.where}`;
-        }
-        break;
-      }
-
-      case 'delete': {
-        if (!input.table) throw new Error('table required for delete');
-        query = `DELETE FROM ${input.table}`;
-        if (input.where) {
-          query += ` WHERE ${input.where}`;
-        }
-        params = input.params || [];
-        break;
-      }
-
-      default:
-        throw new Error(`Unknown operation: ${input.operation}`);
-    }
-
-    const result = await client.query(query, params);
-    return {
-      affectedRows: result.rowCount || 0,
-      insertedId: result.rows?.[0]?.id?.toString(),
-    };
-  } finally {
-    client.release();
-  }
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/db-query.ts

@@ -1,35 +0,0 @@
-import { Pool } from 'pg';
-import { config } from '../config';
-
-const pool = new Pool({ connectionString: config.database.url });
-
-export interface DbQueryInput {
-  query: string;
-  params?: any[];
-  datasource?: string;
-  timeout?: number;
-}
-
-export interface DbQueryOutput {
-  rows: any[];
-  rowCount: number;
-}
-
-/**
- * Execute a database SELECT query.
- */
-export async function dbQuery(input: DbQueryInput): Promise<DbQueryOutput> {
-  const client = await pool.connect();
-  try {
-    if (input.timeout) {
-      await client.query(`SET statement_timeout = ${input.timeout}`);
-    }
-    const result = await client.query(input.query, input.params || []);
-    return {
-      rows: result.rows,
-      rowCount: result.rowCount || 0,
-    };
-  } finally {
-    client.release();
-  }
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/http-request.ts

@@ -1,54 +0,0 @@
-import axios, { AxiosRequestConfig } from 'axios';
-
-export interface HttpRequestInput {
-  url: string;
-  method: string;
-  headers?: Record<string, string>;
-  body?: any;
-  timeout?: number;
-  authentication?: string;
-  followRedirects?: boolean;
-  responseFormat?: 'json' | 'text' | 'binary';
-  ignoreSslErrors?: boolean;
-}
-
-export interface HttpRequestOutput {
-  status: number;
-  data: any;
-  headers: Record<string, string>;
-}
-
-/**
- * Execute an HTTP request activity.
- */
-export async function httpRequest(input: HttpRequestInput): Promise<HttpRequestOutput> {
-  const axiosConfig: AxiosRequestConfig = {
-    url: input.url,
-    method: input.method.toLowerCase() as any,
-    headers: input.headers || {},
-    timeout: input.timeout || 30000,
-    maxRedirects: input.followRedirects === false ? 0 : 5,
-    validateStatus: () => true, // Don't throw on non-2xx
-  };
-
-  if (input.body && ['post', 'put', 'patch'].includes(axiosConfig.method as string)) {
-    axiosConfig.data = input.body;
-  }
-
-  if (input.ignoreSslErrors) {
-    const https = await import('https');
-    axiosConfig.httpsAgent = new https.Agent({ rejectUnauthorized: false });
-  }
-
-  if (input.responseFormat === 'binary') {
-    axiosConfig.responseType = 'arraybuffer';
-  }
-
-  const response = await axios(axiosConfig);
-
-  return {
-    status: response.status,
-    data: response.data,
-    headers: response.headers as Record<string, string>,
-  };
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/index.ts

@@ -1,6 +0,0 @@
-export { httpRequest } from './http-request';
-export { dbQuery } from './db-query';
-export { dbExecute } from './db-execute';
-export { sendNotification } from './send-notification';
-export { codeExecute } from './code-execute';
-export { reportNodeStatus, reportWorkflowStatus, createCronInstance } from './reporting';

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/reporting.ts

@@ -1,85 +0,0 @@
-import { Pool } from 'pg';
-import { config } from '../config';
-import { ReportNodeStatusInput, ReportWorkflowStatusInput } from '../dsl/types';
-
-const pool = new Pool({ connectionString: config.database.url });
-
-/**
- * Report a node's execution status to the database.
- */
-export async function reportNodeStatus(input: ReportNodeStatusInput): Promise<void> {
-  const { instanceId, nodeId, nodeType, nodeLabel, status, input: nodeInput, output, error } = input;
-
-  if (status === 'RUNNING') {
-    // Create or update node execution record with RUNNING status
-    await pool.query(
-      `INSERT INTO t_workflow_node_execution (instance_id, node_id, node_type, node_label, status, input, started_at, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW(), NOW())
-       ON CONFLICT (instance_id, node_id) DO UPDATE SET
-         status = $5, input = $6, started_at = NOW(), updated_at = NOW()`,
-      [instanceId, nodeId, nodeType, nodeLabel || null, status, nodeInput ? JSON.stringify(nodeInput) : null],
-    );
-  } else {
-    // Update with final status
-    await pool.query(
-      `UPDATE t_workflow_node_execution
-       SET status = $1, output = $2, error = $3, finished_at = NOW(), updated_at = NOW()
-       WHERE instance_id = $4 AND node_id = $5`,
-      [status, output ? JSON.stringify(output) : null, error ? JSON.stringify(error) : null, instanceId, nodeId],
-    );
-  }
-}
-
-/**
- * Create a workflow instance for a cron-triggered run.
- * Used by cronTriggerWorkflow before delegating to dslWorkflow.
- */
-export async function createCronInstance(input: {
-  workflowId: number;
-  versionId: number;
-  scheduleId: string;
-}): Promise<{ instanceId: number }> {
-  const { rows } = await pool.query(
-    `INSERT INTO t_workflow_instance
-       (workflow_id, version_id, status, context, creator, created_at, updated_at)
-     VALUES ($1, $2, 'PENDING', $3, 'cron', NOW(), NOW())
-     RETURNING id`,
-    [
-      input.workflowId,
-      input.versionId,
-      JSON.stringify({ scheduleId: input.scheduleId, scheduledAt: new Date().toISOString() }),
-    ],
-  );
-  return { instanceId: Number(rows[0].id) };
-}
-
-/**
- * Report overall workflow execution status.
- */
-export async function reportWorkflowStatus(input: ReportWorkflowStatusInput): Promise<void> {
-  const { instanceId, status, result } = input;
-
-  const updates: string[] = ['status = $1', 'updated_at = NOW()'];
-  const values: any[] = [status];
-  let paramIdx = 2;
-
-  if (status === 'RUNNING') {
-    updates.push(`started_at = NOW()`);
-  }
-
-  if (status === 'COMPLETED' || status === 'FAILED' || status === 'CANCELLED') {
-    updates.push(`finished_at = NOW()`);
-  }
-
-  if (result !== undefined) {
-    updates.push(`result = $${paramIdx}`);
-    values.push(JSON.stringify(result));
-    paramIdx++;
-  }
-
-  values.push(instanceId);
-  await pool.query(
-    `UPDATE t_workflow_instance SET ${updates.join(', ')} WHERE id = $${paramIdx}`,
-    values,
-  );
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/activities/send-notification.ts

@@ -1,47 +0,0 @@
-export interface SendNotificationInput {
-  channel: 'email' | 'slack' | 'webhook' | 'dingtalk' | 'wecom';
-  recipients: string[];
-  subject?: string;
-  message: string;
-  templateId?: string;
-}
-
-export interface SendNotificationOutput {
-  sent: boolean;
-  messageId: string;
-}
-
-/**
- * Send a notification via the configured channel.
- * Currently stubs — implement actual integrations as needed.
- */
-export async function sendNotification(input: SendNotificationInput): Promise<SendNotificationOutput> {
-  const { channel, recipients, subject, message } = input;
-
-  console.log(`[Notification] channel=${channel} recipients=${recipients.join(',')} subject=${subject || ''}`);
-  console.log(`[Notification] message: ${message}`);
-
-  // TODO: Implement actual notification channels
-  // For now, log and return success
-  switch (channel) {
-    case 'webhook': {
-      // For webhook channel, POST to each recipient URL
-      const axios = (await import('axios')).default;
-      for (const url of recipients) {
-        await axios.post(url, { subject, message });
-      }
-      break;
-    }
-    case 'email':
-    case 'slack':
-    case 'dingtalk':
-    case 'wecom':
-      // Stub: log only
-      break;
-  }
-
-  return {
-    sent: true,
-    messageId: `notif_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-  };
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/config.ts

@@ -1,13 +0,0 @@
-import * as dotenv from 'dotenv';
-dotenv.config();
-
-export const config = {
-  temporal: {
-    address: process.env.TEMPORAL_ADDRESS || 'localhost:7233',
-    namespace: process.env.TEMPORAL_NAMESPACE || 'default',
-    taskQueue: process.env.TEMPORAL_TASK_QUEUE || 'workflow-execution',
-  },
-  database: {
-    url: process.env.DATABASE_URL || 'postgresql://kavenma:kavenma@127.0.0.1:5432/gadmin_demo?schema=public',
-  },
-};

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/condition.ts

@@ -1,101 +0,0 @@
-/**
- * Condition evaluation for if_else and switch nodes.
- */
-
-export interface ConditionRule {
-  field: string;
-  operator: string;
-  value: string;
-}
-
-/**
- * Evaluate a single condition rule against a context value.
- */
-export function evaluateRule(fieldValue: any, operator: string, compareValue: string): boolean {
-  switch (operator) {
-    case 'equals':
-    case '==':
-      return String(fieldValue) === compareValue;
-    case 'notEquals':
-    case '!=':
-      return String(fieldValue) !== compareValue;
-    case 'contains':
-      return String(fieldValue).includes(compareValue);
-    case 'notContains':
-      return !String(fieldValue).includes(compareValue);
-    case 'startsWith':
-      return String(fieldValue).startsWith(compareValue);
-    case 'endsWith':
-      return String(fieldValue).endsWith(compareValue);
-    case 'greaterThan':
-    case '>':
-      return Number(fieldValue) > Number(compareValue);
-    case 'lessThan':
-    case '<':
-      return Number(fieldValue) < Number(compareValue);
-    case 'greaterThanOrEqual':
-    case '>=':
-      return Number(fieldValue) >= Number(compareValue);
-    case 'lessThanOrEqual':
-    case '<=':
-      return Number(fieldValue) <= Number(compareValue);
-    case 'isEmpty':
-      return fieldValue == null || fieldValue === '' || (Array.isArray(fieldValue) && fieldValue.length === 0);
-    case 'isNotEmpty':
-      return fieldValue != null && fieldValue !== '' && !(Array.isArray(fieldValue) && fieldValue.length === 0);
-    case 'regex':
-      try {
-        return new RegExp(compareValue).test(String(fieldValue));
-      } catch {
-        return false;
-      }
-    default:
-      return false;
-  }
-}
-
-/**
- * Evaluate multiple condition rules with AND/OR combinator.
- */
-export function evaluateConditions(
-  conditions: ConditionRule[],
-  contextData: Record<string, any>,
-  combineOperation: 'AND' | 'OR' = 'AND',
-): boolean {
-  if (conditions.length === 0) return true;
-
-  const results = conditions.map((rule) => {
-    const fieldValue = getNestedValue(contextData, rule.field);
-    return evaluateRule(fieldValue, rule.operator, rule.value);
-  });
-
-  return combineOperation === 'AND'
-    ? results.every(Boolean)
-    : results.some(Boolean);
-}
-
-/**
- * Evaluate a switch node — returns the matched case value or "default".
- */
-export function evaluateSwitch(
-  field: string,
-  cases: Array<{ value: string; label: string }>,
-  contextData: Record<string, any>,
-): string {
-  const fieldValue = String(getNestedValue(contextData, field) ?? '');
-  const matched = cases.find((c) => c.value === fieldValue);
-  return matched ? matched.value : 'default';
-}
-
-/**
- * Get a nested value from an object using dot-notation path.
- */
-function getNestedValue(obj: Record<string, any>, path: string): any {
-  const parts = path.split('.');
-  let current: any = obj;
-  for (const part of parts) {
-    if (current == null) return undefined;
-    current = current[part];
-  }
-  return current;
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/context.ts

@@ -1,58 +0,0 @@
-/**
- * Workflow execution context — a shared data store that flows between nodes.
- * Each node can read from context and write its output back.
- */
-export class ExecutionContext {
-  private data: Record<string, any>;
-
-  constructor(initialData: Record<string, any> = {}) {
-    this.data = { ...initialData };
-  }
-
-  /** Get a value by dot-notation path (e.g. "node1.data.email") */
-  get(path: string): any {
-    const parts = path.split('.');
-    let current: any = this.data;
-    for (const part of parts) {
-      if (current == null) return undefined;
-      current = current[part];
-    }
-    return current;
-  }
-
-  /** Set a value by key */
-  set(key: string, value: any): void {
-    this.data[key] = value;
-  }
-
-  /** Merge node output into context under the node's ID */
-  mergeNodeOutput(nodeId: string, output: Record<string, any>): void {
-    this.data[nodeId] = output;
-  }
-
-  /** Get the full context object */
-  toJSON(): Record<string, any> {
-    return { ...this.data };
-  }
-
-  /** Resolve template strings like "{{node1.data.email}}" within a value */
-  resolveTemplates(value: any): any {
-    if (typeof value === 'string') {
-      return value.replace(/\{\{(.+?)\}\}/g, (_, path) => {
-        const resolved = this.get(path.trim());
-        return resolved !== undefined ? String(resolved) : '';
-      });
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => this.resolveTemplates(v));
-    }
-    if (value && typeof value === 'object') {
-      const result: Record<string, any> = {};
-      for (const [k, v] of Object.entries(value)) {
-        result[k] = this.resolveTemplates(v);
-      }
-      return result;
-    }
-    return value;
-  }
-}