@apso/cli 0.13.0 → 0.15.0

package/dist/lib/doctor/types.d.ts

@@ -0,0 +1,35 @@
+import { Entity } from "../types/entity";
+import { RelationshipMap } from "../types/relationship";
+import { TargetLanguage } from "../types/generator";
+/**
+ * A single finding from a diagnostic check.
+ */
+export interface DiagnosticFinding {
+    /** Check identifier (e.g. "pk-strategy") */
+    check: string;
+    /** Severity level */
+    severity: "error" | "warning" | "info";
+    /** Human-readable description */
+    message: string;
+    /** Affected entity name */
+    entity?: string;
+    /** Affected file path (relative to project root) */
+    file?: string;
+    /** Suggested fix */
+    suggestion?: string;
+}
+/**
+ * Context passed to each diagnostic check function.
+ */
+export interface DiagnosticContext {
+    /** Parsed entities from .apsorc */
+    entities: Entity[];
+    /** Relationship map from .apsorc */
+    relationshipMap: RelationshipMap;
+    /** Root folder from .apsorc (e.g. "src") */
+    rootFolder: string;
+    /** Target language */
+    language: TargetLanguage;
+    /** Absolute path to the project root (where .apsorc lives) */
+    projectRoot: string;
+}

package/dist/lib/doctor/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/migrate/sandbox.js

@@ -18,6 +18,7 @@ const paths_1 = require("../config/paths");
 const snapshot_1 = require("./snapshot");
 const field_1 = require("../utils/field");
 const casing_1 = require("../utils/casing");
+const relationships_1 = require("../utils/relationships");
 /**
  * Get the sandbox data directory for PGlite persistence.
  */
@@ -57,11 +58,12 @@ async function resetPGliteSingleton() {
  * Clears TypeORM's global metadata storage first to prevent cross-contamination
  * between runs.
  */
-function buildEntityClasses(entities) {
+function buildEntityClasses(entities, relationshipMap = {}) {
     var _a, _b;
     clearTypeOrmMetadata();
     const typeorm = require("typeorm");
     const classes = [];
+    const classMap = new Map();
     for (const entityDef of entities) {
         const className = entityDef.name;
         const tableName = (0, casing_1.snakeCase)(entityDef.name);
@@ -122,9 +124,125 @@ function buildEntityClasses(entities) {
             }
         }
         classes.push(EntityClass);
+        classMap.set(entityDef.name, EntityClass);
+    }
+    for (const entityDef of entities) {
+        const EntityClass = classMap.get(entityDef.name);
+        if (!EntityClass)
+            continue;
+        const relationships = (0, relationships_1.getRelationshipForTemplate)(entityDef.name, relationshipMap[entityDef.name] || [], entities);
+        for (const relationship of relationships) {
+            const targetClass = classMap.get(relationship.name);
+            if (!targetClass)
+                continue;
+            const inversePropertyName = relationship.inverseSidePropertyName ||
+                relationship.inversePropertyName ||
+                entityDef.name;
+            const relationOptions = {};
+            if (relationship.nullable !== undefined) {
+                relationOptions.nullable = relationship.nullable;
+            }
+            if (relationship.cascadeDelete) {
+                relationOptions.onDelete = "CASCADE";
+            }
+            if (relationship.type === "ManyToOne") {
+                if (relationship.index) {
+                    typeorm.Index()(EntityClass.prototype, relationship.relationshipName);
+                }
+                const inverseSide = relationship.biDirectional
+                    ? (target) => target[inversePropertyName]
+                    : undefined;
+                typeorm.ManyToOne(() => targetClass, inverseSide, relationOptions)(EntityClass.prototype, relationship.relationshipName);
+                typeorm.JoinColumn({ name: relationship.camelCasedId })(EntityClass.prototype, relationship.relationshipName);
+            }
+            if (relationship.type === "OneToMany" && relationship.biDirectional) {
+                typeorm.OneToMany(() => targetClass, (target) => target[inversePropertyName])(EntityClass.prototype, relationship.pluralizedRelationshipName);
+            }
+            if (relationship.type === "ManyToMany") {
+                const inverseSide = relationship.biDirectional
+                    ? (target) => target[inversePropertyName]
+                    : undefined;
+                typeorm.ManyToMany(() => targetClass, inverseSide)(EntityClass.prototype, relationship.pluralizedRelationshipName);
+                if (relationship.joinTable) {
+                    const joinTableOptions = {};
+                    if (relationship.joinTableName) {
+                        joinTableOptions.name = relationship.joinTableName;
+                    }
+                    if (relationship.joinColumnName) {
+                        joinTableOptions.joinColumn = {
+                            name: relationship.joinColumnName,
+                            referencedColumnName: "id",
+                        };
+                    }
+                    if (relationship.inverseJoinColumnName) {
+                        joinTableOptions.inverseJoinColumn = {
+                            name: relationship.inverseJoinColumnName,
+                            referencedColumnName: "id",
+                        };
+                    }
+                    typeorm.JoinTable(Object.keys(joinTableOptions).length > 0
+                        ? joinTableOptions
+                        : undefined)(EntityClass.prototype, relationship.pluralizedRelationshipName);
+                }
+            }
+            if (relationship.type === "OneToOne") {
+                const inverseSide = relationship.biDirectional
+                    ? (target) => target[inversePropertyName]
+                    : undefined;
+                typeorm.OneToOne(() => targetClass, inverseSide, relationOptions)(EntityClass.prototype, relationship.relationshipName);
+                if (relationship.joinTable) {
+                    typeorm.JoinColumn()(EntityClass.prototype, relationship.relationshipName);
+                }
+            }
+        }
     }
     return classes;
 }
+function snapshotRelationships(relationshipMap) {
+    return Object.entries(relationshipMap)
+        .flatMap(([from, relationships]) => relationships.map((relationship) => {
+        var _a;
+        return ({
+            from,
+            to: relationship.name,
+            type: relationship.type,
+            to_name: (_a = relationship.referenceName) !== null && _a !== void 0 ? _a : undefined,
+            nullable: relationship.nullable,
+            bi_directional: relationship.biDirectional,
+            cascadeDelete: relationship.cascadeDelete,
+            index: relationship.index,
+            join: relationship.join,
+            joinTableName: relationship.joinTableName,
+            joinColumnName: relationship.joinColumnName,
+            inverseJoinColumnName: relationship.inverseJoinColumnName,
+            inverseReferenceName: relationship.inverseReferenceName,
+        });
+    }))
+        .sort((a, b) => `${a.from}:${a.to}:${a.type}:${a.to_name || ""}`.localeCompare(`${b.from}:${b.to}:${b.type}:${b.to_name || ""}`));
+}
+function relationshipMapFromSnapshot(relationships = []) {
+    const relationshipMap = {};
+    for (const relationship of relationships) {
+        relationshipMap[relationship.from] = [
+            ...(relationshipMap[relationship.from] || []),
+            {
+                name: relationship.to,
+                type: relationship.type,
+                referenceName: relationship.to_name,
+                nullable: relationship.nullable,
+                biDirectional: relationship.bi_directional,
+                cascadeDelete: relationship.cascadeDelete,
+                index: relationship.index,
+                join: relationship.join,
+                joinTableName: relationship.joinTableName,
+                joinColumnName: relationship.joinColumnName,
+                inverseJoinColumnName: relationship.inverseJoinColumnName,
+                inverseReferenceName: relationship.inverseReferenceName,
+            },
+        ];
+    }
+    return relationshipMap;
+}
 /**
  * Create a TypeORM DataSource configured for PGlite with in-memory entity classes.
  */
@@ -185,6 +303,7 @@ async function runMigrationSandbox(current, projectDir) {
                 scopeBy: e.scopeBy,
             });
         }),
+        relationships: snapshotRelationships(current.relationshipMap),
     };
     // Quick check: has anything changed?
     if (snapshot && !schemaChanged(currentSnapshot, snapshot)) {
@@ -221,7 +340,7 @@ async function runMigrationSandbox(current, projectDir) {
             : [];
         // Step 1: Establish baseline with previous schema
         if (previousEntities.length > 0) {
-            const prevClasses = buildEntityClasses(previousEntities);
+            const prevClasses = buildEntityClasses(previousEntities, relationshipMapFromSnapshot(snapshot === null || snapshot === void 0 ? void 0 : snapshot.relationships));
             const prevDs = await createPGliteDataSource(prevClasses);
             await prevDs.initialize();
             await prevDs.synchronize();
@@ -230,7 +349,7 @@ async function runMigrationSandbox(current, projectDir) {
             // The PGlite in-memory database persists in the singleton.
         }
         // Step 2: Compute diff with current schema
-        const currentClasses = buildEntityClasses(current.entities);
+        const currentClasses = buildEntityClasses(current.entities, current.relationshipMap);
         const currentDs = await createPGliteDataSource(currentClasses);
         await currentDs.initialize();
         try {
@@ -314,6 +433,7 @@ function applyMigration(current, projectDir) {
                 scopeBy: e.scopeBy,
             });
         }),
+        relationships: snapshotRelationships(current.relationshipMap),
     };
     (0, snapshot_1.writeSnapshot)(snapshot, projectDir);
 }
@@ -333,5 +453,7 @@ exports.resetSandbox = resetSandbox;
  * Simple deep comparison between current and snapshot schemas.
  */
 function schemaChanged(current, snapshot) {
-    return (JSON.stringify(current.entities) !== JSON.stringify(snapshot.entities));
+    return (JSON.stringify(current.entities) !== JSON.stringify(snapshot.entities) ||
+        JSON.stringify(current.relationships || []) !==
+            JSON.stringify(snapshot.relationships || []));
 }

package/dist/lib/migrate/snapshot.d.ts

@@ -57,6 +57,7 @@ export interface ComparableSchema {
         updated_at?: boolean;
         scopeBy?: string | string[];
     }>;
+    relationships?: ApsorcSnapshot["relationships"];
 }
 /**
  * Read the saved schema snapshot, or null if none exists.

package/dist/lib/migrate/snapshot.js

@@ -95,6 +95,9 @@ function hasChanges(current, snapshot) {
             return true;
         }
     }
+    if (normalize(current.relationships || []) !== normalize(snapshot.relationships || [])) {
+        return true;
+    }
     return false;
 }
 exports.hasChanges = hasChanges;

package/dist/lib/templates/go/utils/query.eta

@@ -222,19 +222,21 @@ func applyOperator(query *gorm.DB, field, op, value string, useOr bool) *gorm.DB
 		where = query.Or
 	}
 
+	cv := coerceValue(value)
+
 	switch op {
 	case "$eq":
-		return where(fmt.Sprintf("%s = ?", field), value)
+		return where(fmt.Sprintf("%s = ?", field), cv)
 	case "$ne":
-		return where(fmt.Sprintf("%s != ?", field), value)
+		return where(fmt.Sprintf("%s != ?", field), cv)
 	case "$gt":
-		return where(fmt.Sprintf("%s > ?", field), value)
+		return where(fmt.Sprintf("%s > ?", field), cv)
 	case "$gte":
-		return where(fmt.Sprintf("%s >= ?", field), value)
+		return where(fmt.Sprintf("%s >= ?", field), cv)
 	case "$lt":
-		return where(fmt.Sprintf("%s < ?", field), value)
+		return where(fmt.Sprintf("%s < ?", field), cv)
 	case "$lte":
-		return where(fmt.Sprintf("%s <= ?", field), value)
+		return where(fmt.Sprintf("%s <= ?", field), cv)
 	case "$starts":
 		return where(fmt.Sprintf("%s LIKE ?", field), value+"%")
 	case "$ends":
@@ -244,9 +246,9 @@ func applyOperator(query *gorm.DB, field, op, value string, useOr bool) *gorm.DB
 	case "$excl":
 		return where(fmt.Sprintf("%s NOT LIKE ?", field), "%"+value+"%")
 	case "$in":
-		return where(fmt.Sprintf("%s IN ?", field), splitValue(value))
+		return where(fmt.Sprintf("%s IN ?", field), coerceValues(splitValue(value)))
 	case "$notin":
-		return where(fmt.Sprintf("%s NOT IN ?", field), splitValue(value))
+		return where(fmt.Sprintf("%s NOT IN ?", field), coerceValues(splitValue(value)))
 	case "$isnull":
 		return where(fmt.Sprintf("%s IS NULL", field))
 	case "$notnull":
@@ -254,7 +256,7 @@ func applyOperator(query *gorm.DB, field, op, value string, useOr bool) *gorm.DB
 	case "$between":
 		vals := splitValue(value)
 		if len(vals) >= 2 {
-			return where(fmt.Sprintf("%s BETWEEN ? AND ?", field), vals[0], vals[1])
+			return where(fmt.Sprintf("%s BETWEEN ? AND ?", field), coerceValue(vals[0]), coerceValue(vals[1]))
 		}
 		return query
 	case "$eqL":
@@ -299,3 +301,29 @@ func splitValue(value string) []string {
 	}
 	return result
 }
+
+// coerceValue converts a string query parameter to a typed value.
+// Booleans and numbers are converted so the database driver sends the
+// correct wire type instead of a raw string.
+func coerceValue(value string) interface{} {
+	low := strings.ToLower(value)
+	if low == "true" || low == "false" || low == "yes" || low == "no" || low == "1" || low == "0" {
+		return low == "true" || low == "yes" || low == "1"
+	}
+	if v, err := strconv.ParseInt(value, 10, 64); err == nil {
+		return v
+	}
+	if v, err := strconv.ParseFloat(value, 64); err == nil {
+		return v
+	}
+	return value
+}
+
+// coerceValues applies coerceValue to each element in a slice.
+func coerceValues(values []string) []interface{} {
+	result := make([]interface{}, len(values))
+	for i, v := range values {
+		result[i] = coerceValue(v)
+	}
+	return result
+}

package/dist/lib/templates/python/utils/query.eta

@@ -6,7 +6,7 @@ import math
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, TypeVar
 
-from sqlalchemy import asc, desc, func, or_
+from sqlalchemy import Boolean, Date, DateTime, Float, Integer, Numeric, asc, desc, func, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 from sqlalchemy.sql import Select, select
@@ -65,30 +65,58 @@ class PaginatedResult:
 # Operator registry
 # ---------------------------------------------------------------------------
 
+def _coerce_value(col: Any, value: str) -> Any:
+    """Coerce a string query param value to match the column's SQL type."""
+    try:
+        col_type = col.property.columns[0].type
+    except (AttributeError, IndexError):
+        return value
+
+    if isinstance(col_type, Boolean):
+        return value.lower() in ("true", "1", "yes")
+    if isinstance(col_type, (Integer,)):
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return value
+    if isinstance(col_type, (Float, Numeric)):
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            return value
+    return value
+
+
+def _coerce_list(col: Any, values: List[str]) -> List[Any]:
+    """Coerce a list of string values to match the column's SQL type."""
+    return [_coerce_value(col, v) for v in values]
+
+
 def _apply_operator(model: Any, field_name: str, op: str, value: str) -> Any:
     """Return a SQLAlchemy filter expression for the given operator."""
     col = getattr(model, field_name, None)
     if col is None:
         return None
 
+    typed_value = _coerce_value(col, value)
     lower_col = func.lower(col)
 
     operators: Dict[str, Any] = {
-        "$eq": lambda: col == value,
-        "$ne": lambda: col != value,
-        "$gt": lambda: col > value,
-        "$gte": lambda: col >= value,
-        "$lt": lambda: col < value,
-        "$lte": lambda: col <= value,
+        "$eq": lambda: col == typed_value,
+        "$ne": lambda: col != typed_value,
+        "$gt": lambda: col > typed_value,
+        "$gte": lambda: col >= typed_value,
+        "$lt": lambda: col < typed_value,
+        "$lte": lambda: col <= typed_value,
         "$starts": lambda: col.like(f"{value}%"),
         "$ends": lambda: col.like(f"%{value}"),
         "$cont": lambda: col.like(f"%{value}%"),
         "$excl": lambda: ~col.like(f"%{value}%"),
-        "$in": lambda: col.in_(_split_value(value)),
-        "$notin": lambda: ~col.in_(_split_value(value)),
+        "$in": lambda: col.in_(_coerce_list(col, _split_value(value))),
+        "$notin": lambda: ~col.in_(_coerce_list(col, _split_value(value))),
         "$isnull": lambda: col.is_(None),
         "$notnull": lambda: col.isnot(None),
-        "$between": lambda: col.between(*_split_value(value)[:2]),
+        "$between": lambda: col.between(*_coerce_list(col, _split_value(value)[:2])),
         "$eqL": lambda: lower_col == value.lower(),
         "$neL": lambda: lower_col != value.lower(),
         "$startsL": lambda: lower_col.like(f"{value.lower()}%"),

package/dist/lib/utils/template.js

@@ -6,7 +6,7 @@ const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
 const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
 exports.TEMPLATE_REPOS = {
-    typescript: "https://github.com/apsoai/service-template.git",
+    typescript: "https://github.com/apsoai/service-template-ts.git",
     python: "https://github.com/apsoai/service-template-python.git",
     go: "https://github.com/apsoai/service-template-go.git",
 };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@apso/cli",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.13.0",
+      "version": "0.15.0",
       "license": "MIT",
       "dependencies": {
         "@electric-sql/pglite": "^0.2.17",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.13.0",
+  "version": "0.15.0",
   "commands": {
     "config": {
       "id": "config",
@@ -73,7 +73,7 @@
     },
     "dev": {
       "id": "dev",
-      "description": "Start the local development server using Docker Compose",
+      "description": "Start the local development server. Detects project language and database type from .apsorc and .env.",
       "strict": true,
       "pluginName": "@apso/cli",
       "pluginAlias": "@apso/cli",
@@ -81,22 +81,56 @@
       "aliases": [],
       "examples": [
         "$ apso dev",
-        "$ apso dev --build",
-        "$ apso dev --detach",
-        "$ apso dev --build --detach"
+        "$ apso dev --docker",
+        "$ apso dev --docker --build"
       ],
       "flags": {
+        "docker": {
+          "name": "docker",
+          "type": "boolean",
+          "description": "Use Docker Compose instead of the native dev stack",
+          "allowNo": false
+        },
         "detach": {
           "name": "detach",
           "type": "boolean",
           "char": "d",
-          "description": "Run containers in the background",
+          "description": "Run containers in the background (Docker mode only)",
           "allowNo": false
         },
         "build": {
           "name": "build",
           "type": "boolean",
-          "description": "Rebuild images before starting",
+          "description": "Rebuild images before starting (Docker mode only)",
+          "allowNo": false
+        }
+      },
+      "args": {}
+    },
+    "doctor": {
+      "id": "doctor",
+      "description": "Run diagnostic checks on generated code and optionally file a GitHub issue with findings",
+      "strict": true,
+      "pluginName": "@apso/cli",
+      "pluginAlias": "@apso/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "$ apso doctor",
+        "$ apso doctor --json",
+        "$ apso doctor --report"
+      ],
+      "flags": {
+        "report": {
+          "name": "report",
+          "type": "boolean",
+          "description": "File a GitHub issue with diagnostic findings (requires gh CLI)",
+          "allowNo": false
+        },
+        "json": {
+          "name": "json",
+          "type": "boolean",
+          "description": "Output findings as JSON instead of human-readable text",
           "allowNo": false
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "mcpName": "io.github.apsoai/apso",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",