instant-cli 1.0.40 → 1.0.41-branch-python-sdk-v1.26586025551.1

package/src/index.ts

@@ -21,6 +21,7 @@ import { infoCommand } from './commands/info.ts';
 import { pullCommand } from './commands/pull.ts';
 import type { SchemaPermsOrBoth } from './commands/pull.ts';
 import { claimCommand } from './commands/claim.ts';
+import { genpyCommand } from './commands/genpy.ts';
 import { pushCommand } from './commands/push.ts';
 import { explorerCmd } from './commands/explorer.ts';
 import { queryCmd } from './commands/query.ts';
@@ -836,6 +837,28 @@ Environment Variables:
     );
   });
 
+export const genpyDef = program
+  .command('genpy')
+  .description(
+    'Generate a schema-bound instant_types.py from instant.schema.ts.',
+  )
+  .option(
+    '-o --out-dir <path>',
+    'Directory to write instant_types.py into. Defaults to the schema file directory.',
+  )
+  .addHelpText(
+    'after',
+    `
+Environment Variables:
+  INSTANT_SCHEMA_FILE_PATH    Override schema file location (default: instant.schema.ts)
+`,
+  )
+  .action(async (opts) => {
+    return runCommandEffect(
+      genpyCommand({ outDir: opts.outDir }).pipe(Effect.provide(BaseLayerLive)),
+    );
+  });
+
 export const claimDef = program
   .command('claim')
   .description('Transfer a temporary app into your Instant account')

package/src/util/loadConfig.ts

@@ -14,18 +14,15 @@ const toArray = <T>(value: Arrayable<T>): T[] =>
   Array.isArray(value) ? value : [value];
 
 /**
- * Resolve @instantdb packages from CLI's dependency tree.
- * For Deno projects, we alias all common @instantdb packages to @instantdb/core
- * since they all re-export the schema types from core.
+ * Resolve @instantdb packages from the CLI's own dependencies for
+ * projects without node_modules. All @instantdb packages re-export
+ * schema types from core, so a single core alias covers them all.
  */
 function getInstantAliases(): Record<string, string> | null {
   try {
     const require = createRequire(import.meta.url);
-    // Resolve @instantdb/core directly from CLI's dependencies
     const corePackageJson = require.resolve('@instantdb/core/package.json');
     const coreDir = path.dirname(corePackageJson);
-    // All @instantdb packages re-export schema types from core,
-    // so we can alias them all to core for schema loading purposes
     return {
       '@instantdb/core': coreDir,
       '@instantdb/react': coreDir,
@@ -39,7 +36,7 @@ function getInstantAliases(): Record<string, string> | null {
   }
 }
 
-function withDenoAliases<T>(
+function withAliases<T>(
   opts: LoadConfigOptions<T>,
   alias: Record<string, string>,
 ): LoadConfigOptions<T> {
@@ -76,14 +73,13 @@ export async function loadConfig<T>(
   opts: LoadConfigOptions<T>,
 ): Promise<LoadConfigResult<T>> {
   const projectInfo = await findProjectDir();
-  const isDeno = projectInfo?.type === 'deno';
+  const needsAliases =
+    projectInfo?.type === 'deno' || projectInfo?.type === 'python';
 
-  // Deno projects don't have node_modules, so we need to alias @instantdb/*
-  // packages to resolve from the CLI's own dependencies
   let res;
-  if (isDeno) {
+  if (needsAliases) {
     const alias = getInstantAliases();
-    res = await _loadConfig(alias ? withDenoAliases(opts, alias) : opts);
+    res = await _loadConfig(alias ? withAliases(opts, alias) : opts);
   } else {
     res = await _loadConfig(opts);
   }

package/src/util/projectDir.ts

@@ -2,32 +2,53 @@ import { packageDirectory } from 'package-directory';
 import { findUp } from 'find-up-simple';
 import path from 'node:path';
 
-export type ProjectType = 'node' | 'deno';
+export type ProjectType = 'node' | 'deno' | 'python';
 
 export interface ProjectInfo {
   dir: string;
   type: ProjectType;
 }
 
+// Same-directory tie-breaker: Deno > Python > Node. Deno may coexist
+// with package.json for npm interop; pyproject.toml signals Python.
+const TYPE_PRIORITY: Record<ProjectType, number> = {
+  deno: 0,
+  python: 1,
+  node: 2,
+};
+
+const depth = (filepath: string) => filepath.split(path.sep).length;
+
 export async function findProjectDir(
   cwd?: string,
 ): Promise<ProjectInfo | null> {
-  // Check for Deno first. A Deno project may also have a package.json (for npm
-  // compatibility), but if deno.json exists, the user intends to use Deno and
-  // we should use Deno-specific behavior (e.g., resolving @instantdb/* from
-  // CLI's dependencies instead of node_modules).
-  const denoConfig =
-    (await findUp('deno.json', { cwd })) ||
-    (await findUp('deno.jsonc', { cwd }));
-  if (denoConfig) {
-    return { dir: path.dirname(denoConfig), type: 'deno' };
-  }
+  const [denoJson, denoJsonc, pyproject, nodeDir] = await Promise.all([
+    findUp('deno.json', { cwd }),
+    findUp('deno.jsonc', { cwd }),
+    findUp('pyproject.toml', { cwd }),
+    packageDirectory({ cwd }),
+  ]);
 
-  // Fall back to package-directory for Node
-  const nodeDir = await packageDirectory({ cwd });
+  // Push deno.json and deno.jsonc independently so the depth-sort can
+  // pick the nearer one when both exist at different levels.
+  const candidates: { file: string; type: ProjectType }[] = [];
+  if (denoJson) candidates.push({ file: denoJson, type: 'deno' });
+  if (denoJsonc) candidates.push({ file: denoJsonc, type: 'deno' });
+  if (pyproject) candidates.push({ file: pyproject, type: 'python' });
   if (nodeDir) {
-    return { dir: nodeDir, type: 'node' };
+    candidates.push({ file: path.join(nodeDir, 'package.json'), type: 'node' });
   }
 
-  return null;
+  if (candidates.length === 0) return null;
+
+  // Nearest marker wins (deepest path), so a Python project nested in a
+  // Node monorepo isn't misclassified by a parent's package.json.
+  candidates.sort((a, b) => {
+    const depthDiff = depth(b.file) - depth(a.file);
+    return depthDiff !== 0
+      ? depthDiff
+      : TYPE_PRIORITY[a.type] - TYPE_PRIORITY[b.type];
+  });
+
+  return { dir: path.dirname(candidates[0].file), type: candidates[0].type };
 }