@globaltypesystem/gts-ts 0.1.0

package/src/query.ts

@@ -0,0 +1,191 @@
+import { QueryResult } from './types';
+import { GtsStore } from './store';
+import { Gts } from './gts';
+
+export class GtsQuery {
+  static query(store: GtsStore, expression: string, limit: number = 100): QueryResult {
+    try {
+      // Parse the query expression to extract base pattern and filters
+      const { basePattern, filters, error } = this.parseQueryExpression(expression);
+
+      if (error) {
+        return {
+          query: expression,
+          count: 0,
+          items: [],
+          error: error,
+          limit: limit,
+        };
+      }
+
+      const results: any[] = [];
+
+      // Iterate through all entities in the store
+      for (const [id, entity] of store['byId']) {
+        if (results.length >= limit) break;
+
+        // Check if ID matches the pattern
+        if (!this.matchesIDPattern(id, basePattern)) {
+          continue;
+        }
+
+        // Check filters
+        if (!this.matchesFilters(entity.content, filters)) {
+          continue;
+        }
+
+        results.push(entity.content);
+      }
+
+      return {
+        query: expression,
+        count: results.length,
+        items: results,
+        limit: limit,
+      };
+    } catch (error) {
+      return {
+        query: expression,
+        count: 0,
+        items: [],
+        error: error instanceof Error ? error.message : String(error),
+        limit: limit,
+      };
+    }
+  }
+
+  private static parseQueryExpression(expr: string): {
+    basePattern: string;
+    filters: Map<string, string>;
+    error?: string;
+  } {
+    // Split by '[' to separate base pattern from filters
+    const parts = expr.split('[');
+    const basePattern = parts[0].trim();
+    const filters = new Map<string, string>();
+
+    if (parts.length > 1) {
+      // Extract filter string (remove trailing ])
+      let filterStr = parts[1].trim();
+      if (!filterStr.endsWith(']')) {
+        return {
+          basePattern,
+          filters,
+          error: "Invalid query: missing closing bracket ']'",
+        };
+      }
+      filterStr = filterStr.slice(0, -1);
+
+      // Check if base pattern ends with ~ or ~* (type ID/pattern) - filters not allowed on type queries
+      if (basePattern.endsWith('~') || basePattern.endsWith('~*')) {
+        return {
+          basePattern,
+          filters,
+          error: 'Invalid query: filters cannot be used with type patterns (ending with ~ or ~*)',
+        };
+      }
+
+      // Parse filters
+      const filterParts = filterStr.split(',');
+      for (const part of filterParts) {
+        const trimmed = part.trim();
+        if (trimmed.includes('=')) {
+          const [key, ...valueParts] = trimmed.split('=');
+          const value = valueParts
+            .join('=')
+            .trim()
+            .replace(/^["']|["']$/g, '');
+          filters.set(key.trim(), value);
+        }
+      }
+    }
+
+    // Validate the pattern
+    const isWildcard = basePattern.includes('*');
+    const validationError = this.validateQueryPattern(basePattern, isWildcard);
+    if (validationError) {
+      return {
+        basePattern,
+        filters,
+        error: validationError,
+      };
+    }
+
+    return { basePattern, filters };
+  }
+
+  private static validateQueryPattern(basePattern: string, isWildcard: boolean): string | undefined {
+    if (isWildcard) {
+      // Wildcard pattern must end with .* or ~*
+      if (!basePattern.endsWith('.*') && !basePattern.endsWith('~*')) {
+        return 'Invalid query: wildcard patterns must end with .* or ~*';
+      }
+
+      // Validate as wildcard pattern
+      try {
+        // Just check it's a valid pattern format
+        if (!basePattern.startsWith('gts.')) {
+          return "Invalid query: pattern must start with 'gts.'";
+        }
+      } catch (err) {
+        return `Invalid query: ${err}`;
+      }
+    } else {
+      // Non-wildcard pattern must be a complete valid GTS ID
+      try {
+        const result = Gts.parseID(basePattern);
+        if (!result.ok) {
+          return `Invalid query: ${result.error}`;
+        }
+
+        // Check if pattern is incomplete (missing version or type)
+        // A complete GTS ID must end with a version (v1, v1.2) or ~ for types
+        const segments = result.segments || [];
+        if (segments.length === 0) {
+          return 'Invalid query: GTS ID has no valid segments';
+        }
+
+        const lastSeg = segments[segments.length - 1];
+        if (!lastSeg.isType && !lastSeg.verMajor) {
+          return 'Invalid query: incomplete GTS ID pattern';
+        }
+      } catch (err) {
+        return `Invalid query: ${err}`;
+      }
+    }
+
+    return undefined;
+  }
+
+  private static matchesIDPattern(entityID: string, basePattern: string): boolean {
+    // Always use the proper matchIDPattern function which handles wildcards and version matching
+    const matchResult = Gts.matchIDPattern(entityID, basePattern);
+    return matchResult.match;
+  }
+
+  private static matchesFilters(entityContent: any, filters: Map<string, string>): boolean {
+    if (filters.size === 0) {
+      return true;
+    }
+
+    if (!entityContent || typeof entityContent !== 'object') {
+      return false;
+    }
+
+    for (const [key, value] of filters) {
+      const entityValue = String(entityContent[key] ?? '');
+
+      // Support wildcard in filter values
+      if (value === '*') {
+        // Wildcard matches any non-empty value
+        if (!entityValue || entityValue === 'null' || entityValue === 'undefined') {
+          return false;
+        }
+      } else if (entityValue !== value) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}

package/src/relationships.ts

@@ -0,0 +1,91 @@
+import { RelationshipResult } from './types';
+import { GtsStore } from './store';
+import { Gts } from './gts';
+
+export class GtsRelationships {
+  static resolveRelationships(store: GtsStore, gtsId: string): RelationshipResult {
+    try {
+      const entity = store.get(gtsId);
+      if (!entity) {
+        return {
+          id: gtsId,
+          relationships: [],
+          brokenReferences: [],
+          error: `Entity not found: ${gtsId}`,
+        };
+      }
+
+      const relationships: Set<string> = new Set();
+      const brokenReferences: Set<string> = new Set();
+
+      const visited = new Set<string>();
+      this.findRelationships(store, entity.content, relationships, brokenReferences, visited);
+
+      if (entity.schemaId) {
+        relationships.add(entity.schemaId);
+        const schemaEntity = store.get(entity.schemaId);
+        if (!schemaEntity) {
+          brokenReferences.add(entity.schemaId);
+        }
+      }
+
+      return {
+        id: gtsId,
+        relationships: Array.from(relationships).sort(),
+        brokenReferences: Array.from(brokenReferences).sort(),
+      };
+    } catch (error) {
+      return {
+        id: gtsId,
+        relationships: [],
+        brokenReferences: [],
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private static findRelationships(
+    store: GtsStore,
+    obj: any,
+    relationships: Set<string>,
+    brokenReferences: Set<string>,
+    visited: Set<any>
+  ): void {
+    if (!obj || typeof obj !== 'object' || visited.has(obj)) {
+      return;
+    }
+
+    visited.add(obj);
+
+    if ('$ref' in obj && typeof obj['$ref'] === 'string') {
+      const ref = obj['$ref'];
+      const normalized = ref.startsWith('gts://') ? ref.substring(6) : ref;
+      if (Gts.isValidGtsID(normalized)) {
+        relationships.add(normalized);
+        if (!store.get(normalized)) {
+          brokenReferences.add(normalized);
+        }
+      }
+    }
+
+    if ('x-gts-ref' in obj && typeof obj['x-gts-ref'] === 'string') {
+      const ref = obj['x-gts-ref'];
+      if (Gts.isValidGtsID(ref)) {
+        relationships.add(ref);
+        if (!store.get(ref)) {
+          brokenReferences.add(ref);
+        }
+      }
+    }
+
+    if (Array.isArray(obj)) {
+      for (const item of obj) {
+        this.findRelationships(store, item, relationships, brokenReferences, visited);
+      }
+    } else {
+      for (const value of Object.values(obj)) {
+        this.findRelationships(store, value, relationships, brokenReferences, visited);
+      }
+    }
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import { GtsServer } from './server';
+import { ServerConfig } from './types';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createJsonEntity } from '../index';
+
+const program = new Command();
+
+program
+  .name('gts-server')
+  .description('GTS HTTP Server')
+  .version('0.1.0')
+  .option('-h, --host <host>', 'Host to bind to', '127.0.0.1')
+  .option('-p, --port <port>', 'Port to listen on', '8000')
+  .option('-v, --verbose <level>', 'Verbosity level (0=silent, 1=info, 2=debug)', '1')
+  .option('--path <path>', 'Path to JSON/schema files to preload')
+  .action(async (options) => {
+    const config: ServerConfig = {
+      host: options.host,
+      port: parseInt(options.port, 10),
+      verbose: parseInt(options.verbose, 10),
+      path: options.path,
+    };
+
+    console.log(`Starting GTS server on http://${config.host}:${config.port}`);
+
+    const server = new GtsServer(config);
+
+    // Preload entities from path if provided
+    if (config.path) {
+      await loadEntitiesFromPath(server, config.path);
+    }
+
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+      console.log('\nShutting down server...');
+      await server.stop();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      console.log('\nShutting down server...');
+      await server.stop();
+      process.exit(0);
+    });
+
+    // Start the server
+    await server.start();
+  });
+
+async function loadEntitiesFromPath(server: any, dirPath: string): Promise<void> {
+  if (!fs.existsSync(dirPath)) {
+    console.warn(`Path does not exist: ${dirPath}`);
+    return;
+  }
+
+  const stats = fs.statSync(dirPath);
+  if (!stats.isDirectory()) {
+    console.warn(`Path is not a directory: ${dirPath}`);
+    return;
+  }
+
+  console.log(`Loading entities from: ${dirPath}`);
+  const files = fs.readdirSync(dirPath);
+  let loaded = 0;
+  let errors = 0;
+
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+
+    const filePath = path.join(dirPath, file);
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const data = JSON.parse(content);
+
+      // Handle arrays of entities
+      const entities = Array.isArray(data) ? data : [data];
+
+      for (const entity of entities) {
+        try {
+          const gtsEntity = createJsonEntity(entity);
+          if (gtsEntity.id) {
+            server['store'].register(entity);
+            loaded++;
+            if (server['config'].verbose >= 2) {
+              console.log(`  Loaded: ${gtsEntity.id}`);
+            }
+          }
+        } catch (err) {
+          errors++;
+          if (server['config'].verbose >= 1) {
+            console.warn(`  Failed to load entity from ${file}: ${err}`);
+          }
+        }
+      }
+    } catch (err) {
+      errors++;
+      if (server['config'].verbose >= 1) {
+        console.warn(`  Failed to read ${file}: ${err}`);
+      }
+    }
+  }
+
+  console.log(`Loaded ${loaded} entities (${errors} errors)`);
+}
+
+// Run the CLI if this is the main module
+if (require.main === module) {
+  program.parse(process.argv);
+}