@apso/cli 0.14.0 → 0.15.0

package/dist/commands/dev.d.ts

@@ -3,13 +3,65 @@ export default class Dev extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        docker: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         detach: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         build: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
+    private children;
     run(): Promise<void>;
     /**
-     * Detect whether to use `docker compose` (v2 plugin) or `docker-compose` (v1).
-     * Returns the command parts as an array.
+     * TypeScript: run `npm run dev` which reads DATABASE_TYPE from .env.
+     * PGlite is handled natively by the NestJS app -- no sidecar needed.
+     */
+    private runTypeScript;
+    /**
+     * Python: if pglite, start the pglite-server sidecar first, then uvicorn.
+     */
+    private runPython;
+    /**
+     * Go: if pglite, start the pglite-server sidecar first, then go run.
+     */
+    private runGo;
+    /**
+     * Fallback: run docker compose up (the old behavior).
+     */
+    private runDocker;
+    /**
+     * Detect the project language from .apsorc.
+     * Falls back to typescript if not specified.
+     */
+    private detectLanguage;
+    /**
+     * Read DATABASE_TYPE from .env. Defaults to pglite.
+     */
+    private readDatabaseType;
+    /**
+     * Read a single value from .env.
+     */
+    private readEnvValue;
+    /**
+     * Find .apsorc by walking up from cwd.
+     */
+    private findApsorc;
+    /**
+     * Run `npm install` if node_modules doesn't exist.
+     * Needed for the pglite-server sidecar in Python/Go projects.
+     */
+    private ensureNodeModules;
+    /**
+     * Wait for a TCP port to become reachable.
+     */
+    private waitForPort;
+    /**
+     * Spawn a process in the background and track it for cleanup.
+     */
+    private spawnBackground;
+    /**
+     * Spawn a process and wait for it to exit.
+     */
+    private spawnAndWait;
+    /**
+     * Detect whether to use `docker compose` (v2) or `docker-compose` (v1).
      */
     private detectComposeVariant;
 }

package/dist/commands/dev.js

@@ -4,61 +4,246 @@ const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
 const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
 const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
 class Dev extends base_command_1.default {
+    constructor() {
+        super(...arguments);
+        this.children = [];
+    }
     async run() {
         const { flags } = await this.parse(Dev);
-        // Check Docker is installed
+        if (flags.docker) {
+            return this.runDocker(flags);
+        }
+        const language = this.detectLanguage();
+        const databaseType = this.readDatabaseType();
+        this.log(`Detected language: ${language}`);
+        this.log(`Database type: ${databaseType}`);
+        // Set up signal forwarding for clean shutdown
+        const cleanup = () => {
+            for (const child of this.children) {
+                child.kill("SIGTERM");
+            }
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        try {
+            switch (language) {
+                case "typescript":
+                    await this.runTypeScript();
+                    break;
+                case "python":
+                    await this.runPython(databaseType);
+                    break;
+                case "go":
+                    await this.runGo(databaseType);
+                    break;
+                default:
+                    this.error(`Unsupported language: ${language}. Supported: typescript, python, go.`);
+            }
+        }
+        finally {
+            process.removeListener("SIGINT", cleanup);
+            process.removeListener("SIGTERM", cleanup);
+        }
+    }
+    /**
+     * TypeScript: run `npm run dev` which reads DATABASE_TYPE from .env.
+     * PGlite is handled natively by the NestJS app -- no sidecar needed.
+     */
+    async runTypeScript() {
+        this.log("Starting TypeScript dev server...");
+        await this.spawnAndWait("npm", ["run", "dev"]);
+    }
+    /**
+     * Python: if pglite, start the pglite-server sidecar first, then uvicorn.
+     */
+    async runPython(databaseType) {
+        if (databaseType === "pglite") {
+            this.log("Starting PGlite sidecar...");
+            await this.ensureNodeModules();
+            this.spawnBackground("npm", ["run", "db"]);
+            // Give the sidecar a moment to bind the port
+            await this.waitForPort(5432, 10000);
+        }
+        this.log("Starting Python dev server...");
+        await this.spawnAndWait("uvicorn", [
+            "app.main:app",
+            "--reload",
+            "--host",
+            "0.0.0.0",
+            "--port",
+            this.readEnvValue("PORT") || "3000",
+        ]);
+    }
+    /**
+     * Go: if pglite, start the pglite-server sidecar first, then go run.
+     */
+    async runGo(databaseType) {
+        if (databaseType === "pglite") {
+            this.log("Starting PGlite sidecar...");
+            await this.ensureNodeModules();
+            this.spawnBackground("npm", ["run", "db"]);
+            await this.waitForPort(5432, 10000);
+        }
+        this.log("Starting Go dev server...");
+        await this.spawnAndWait("go", ["run", "cmd/main.go"]);
+    }
+    /**
+     * Fallback: run docker compose up (the old behavior).
+     */
+    async runDocker(flags) {
         if (!shelljs_1.default.which("docker")) {
             this.error("Docker is required but not found. Please install Docker and try again.\nhttps://docs.docker.com/get-docker/");
         }
-        // Detect compose variant (v2 plugin vs v1 standalone)
         const composeCmd = this.detectComposeVariant();
-        // Verify docker-compose.yml exists
         if (!fs.existsSync("docker-compose.yml")) {
             this.error("No docker-compose.yml found in the current directory.\nMake sure you are in an Apso project root.");
         }
-        // Build the command args
         const args = [...composeCmd, "up"];
-        if (flags.build) {
+        if (flags.build)
             args.push("--build");
-        }
-        if (flags.detach) {
+        if (flags.detach)
             args.push("-d");
-        }
         this.log(`Running: ${args.join(" ")}`);
-        const child = (0, child_process_1.spawn)(args[0], args.slice(1), {
+        await this.spawnAndWait(args[0], args.slice(1), {
+            AUTH_DISABLED: "true",
+        });
+    }
+    // --- Helpers ---
+    /**
+     * Detect the project language from .apsorc.
+     * Falls back to typescript if not specified.
+     */
+    detectLanguage() {
+        const apsorcPath = this.findApsorc();
+        if (!apsorcPath) {
+            this.log("No .apsorc found, defaulting to typescript.");
+            return "typescript";
+        }
+        try {
+            const content = fs.readFileSync(apsorcPath, "utf-8");
+            const config = JSON.parse(content);
+            return config.language || "typescript";
+        }
+        catch {
+            this.log("Could not parse .apsorc, defaulting to typescript.");
+            return "typescript";
+        }
+    }
+    /**
+     * Read DATABASE_TYPE from .env. Defaults to pglite.
+     */
+    readDatabaseType() {
+        return this.readEnvValue("DATABASE_TYPE") || "pglite";
+    }
+    /**
+     * Read a single value from .env.
+     */
+    readEnvValue(key) {
+        const envPath = path.resolve(".env");
+        if (!fs.existsSync(envPath))
+            return undefined;
+        const content = fs.readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("#") || !trimmed.includes("="))
+                continue;
+            const [k, ...rest] = trimmed.split("=");
+            if (k.trim() === key)
+                return rest.join("=").trim();
+        }
+        return undefined;
+    }
+    /**
+     * Find .apsorc by walking up from cwd.
+     */
+    findApsorc() {
+        let dir = process.cwd();
+        while (dir !== path.parse(dir).root) {
+            const candidate = path.join(dir, ".apsorc");
+            if (fs.existsSync(candidate))
+                return candidate;
+            dir = path.dirname(dir);
+        }
+        return null;
+    }
+    /**
+     * Run `npm install` if node_modules doesn't exist.
+     * Needed for the pglite-server sidecar in Python/Go projects.
+     */
+    async ensureNodeModules() {
+        if (!fs.existsSync("node_modules")) {
+            this.log("Installing pglite-server dependencies...");
+            await this.spawnAndWait("npm", ["install"]);
+        }
+    }
+    /**
+     * Wait for a TCP port to become reachable.
+     */
+    waitForPort(port, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const start = Date.now();
+            const check = () => {
+                const net = require("net");
+                const sock = net.createConnection({ port, host: "127.0.0.1" }, () => {
+                    sock.destroy();
+                    resolve();
+                });
+                sock.on("error", () => {
+                    sock.destroy();
+                    if (Date.now() - start > timeoutMs) {
+                        reject(new Error(`Port ${port} did not become available within ${timeoutMs}ms`));
+                    }
+                    else {
+                        setTimeout(check, 250);
+                    }
+                });
+            };
+            check();
+        });
+    }
+    /**
+     * Spawn a process in the background and track it for cleanup.
+     */
+    spawnBackground(cmd, args) {
+        const child = (0, child_process_1.spawn)(cmd, args, {
             stdio: "inherit",
-            env: {
-                ...process.env,
-                AUTH_DISABLED: "true",
-            },
+            env: { ...process.env },
         });
-        // Forward signals for clean shutdown
-        const forwardSignal = (signal) => {
-            child.kill(signal);
-        };
-        process.on("SIGINT", forwardSignal);
-        process.on("SIGTERM", forwardSignal);
+        this.children.push(child);
+        child.on("error", (err) => {
+            this.warn(`Background process ${cmd} failed: ${err.message}`);
+        });
+        return child;
+    }
+    /**
+     * Spawn a process and wait for it to exit.
+     */
+    spawnAndWait(cmd, args, extraEnv) {
         return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(cmd, args, {
+                stdio: "inherit",
+                env: { ...process.env, ...extraEnv },
+            });
+            this.children.push(child);
             child.on("close", (code) => {
-                process.removeListener("SIGINT", forwardSignal);
-                process.removeListener("SIGTERM", forwardSignal);
+                this.children = this.children.filter((c) => c !== child);
                 if (code !== 0 && code !== null) {
-                    reject(new Error(`docker compose exited with code ${code}`));
+                    reject(new Error(`${cmd} exited with code ${code}`));
                     return;
                 }
                 resolve();
             });
             child.on("error", (err) => {
-                this.error(`Failed to start Docker Compose: ${err.message}`);
+                this.error(`Failed to start ${cmd}: ${err.message}`);
             });
         });
     }
     /**
-     * Detect whether to use `docker compose` (v2 plugin) or `docker-compose` (v1).
-     * Returns the command parts as an array.
+     * Detect whether to use `docker compose` (v2) or `docker-compose` (v1).
      */
     detectComposeVariant() {
         try {
@@ -66,7 +251,6 @@ class Dev extends base_command_1.default {
             return ["docker", "compose"];
         }
         catch {
-            // Fall back to v1
             if (shelljs_1.default.which("docker-compose")) {
                 return ["docker-compose"];
             }
@@ -74,21 +258,24 @@ class Dev extends base_command_1.default {
         }
     }
 }
-Dev.description = "Start the local development server using Docker Compose";
+Dev.description = "Start the local development server. Detects project language and database type from .apsorc and .env.";
 Dev.examples = [
     `$ apso dev`,
-    `$ apso dev --build`,
-    `$ apso dev --detach`,
-    `$ apso dev --build --detach`,
+    `$ apso dev --docker`,
+    `$ apso dev --docker --build`,
 ];
 Dev.flags = {
+    docker: core_1.Flags.boolean({
+        description: "Use Docker Compose instead of the native dev stack",
+        default: false,
+    }),
     detach: core_1.Flags.boolean({
         char: "d",
-        description: "Run containers in the background",
+        description: "Run containers in the background (Docker mode only)",
         default: false,
     }),
     build: core_1.Flags.boolean({
-        description: "Rebuild images before starting",
+        description: "Rebuild images before starting (Docker mode only)",
         default: false,
     }),
 };

package/dist/commands/init.js

@@ -55,7 +55,7 @@ class Init extends base_command_1.default {
         // Select workspace
         const workspaces = await services_1.workspacesApi.list();
         if (workspaces.length === 0) {
-            this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+            this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
         }
         const { workspace } = await inquirer_1.default.prompt([
             {
@@ -170,7 +170,7 @@ class Init extends base_command_1.default {
         // Select workspace
         const workspaces = await services_1.workspacesApi.list();
         if (workspaces.length === 0) {
-            this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+            this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
         }
         const { workspace } = await inquirer_1.default.prompt([
             {

package/dist/commands/link.js

@@ -44,7 +44,7 @@ class Link extends base_command_1.default {
         else {
             const workspaces = await services_1.workspacesApi.list();
             if (workspaces.length === 0) {
-                this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+                this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
             }
             const response = await inquirer_1.default.prompt([
                 {

package/dist/commands/projects.js

@@ -28,7 +28,7 @@ class Projects extends base_command_1.default {
                 // Prompt
                 const workspaces = await services_1.workspacesApi.list();
                 if (workspaces.length === 0) {
-                    this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+                    this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
                 }
                 const response = await inquirer_1.default.prompt([
                     {

package/dist/lib/config/types.js

@@ -11,8 +11,8 @@ exports.CONFIG_ENV_VARS = exports.DEFAULT_GLOBAL_CONFIG = void 0;
  * Default values for global configuration
  */
 exports.DEFAULT_GLOBAL_CONFIG = {
-    apiUrl: "https://api.apso.ai",
-    webUrl: "https://app.apso.ai",
+    apiUrl: "https://api.apso.dev",
+    webUrl: "https://app.apso.cloud",
     verbose: false,
     noColor: false,
     telemetryDisabled: false,

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.14.0",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.14.0",
+      "version": "0.15.0",
       "license": "MIT",
       "dependencies": {
         "@electric-sql/pglite": "^0.2.17",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.14.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,27 @@
       "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
         }
       },

package/package.json

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