@base44-preview/cli 0.0.15-pr.100.7c491cf → 0.0.15-pr.102.ec2ad29

package/README.md

@@ -70,6 +70,93 @@ base44 deploy
 |---------|-------------|
 | `base44 site deploy` | Deploy built site files to Base44 hosting |
 
+### Types
+
+| Command | Description |
+|---------|-------------|
+| `base44 types` | Generate TypeScript types from entity schemas |
+
+**Options:**
+- `-o, --output <dir>` - Output directory (default: `src/base44`)
+- `--entities-only` - Only generate entity types, skip client types
+
+## TypeScript Type Generation
+
+Generate fully-typed interfaces from your entity schemas for type-safe SDK usage.
+
+### Usage
+
+```bash
+# Generate types (outputs to src/base44/)
+base44 types
+
+# Custom output directory
+base44 types --output ./types
+```
+
+### Generated Files
+
+| File | Contents |
+|------|----------|
+| `entities.ts` | Entity interfaces, CreateInput, UpdateInput, Filter types |
+| `client.ts` | Typed SDK client interface |
+| `index.ts` | Barrel exports |
+
+### Setup with @base44/sdk
+
+1. Generate types:
+   ```bash
+   base44 types
+   ```
+
+2. Add to `tsconfig.json`:
+   ```json
+   {
+     "include": ["src", "src/base44/entities.ts"]
+   }
+   ```
+
+3. Use in your code:
+   ```typescript
+   import { createClient } from '@base44/sdk';
+   import type { TypedBase44Client } from './base44/client';
+
+   const base44 = createClient({ appId: 'my-app' }) as TypedBase44Client;
+
+   // Fully typed!
+   const { items: tasks } = await base44.entities.Task.list();
+   await base44.entities.Task.create({ title: 'Buy milk' });
+   ```
+
+### Example
+
+Given an entity schema:
+```jsonc
+// base44/entities/task.jsonc
+{
+  "name": "Task",
+  "type": "object",
+  "properties": {
+    "title": { "type": "string", "description": "Task title" },
+    "completed": { "type": "boolean", "default": false }
+  },
+  "required": ["title"]
+}
+```
+
+Generated types:
+```typescript
+export interface Task extends BaseEntity {
+  title: string;
+  completed?: boolean;
+}
+
+export interface TaskCreateInput {
+  title: string;
+  completed?: boolean;
+}
+```
+
 ## Configuration
 
 ### Project Configuration
@@ -115,7 +202,12 @@ my-project/
 │       └── my-function/
 │           ├── config.jsonc
 │           └── index.js
-├── src/                       # Your frontend code
+├── src/
+│   ├── base44/                # Generated types (from `base44 types`)
+│   │   ├── entities.ts
+│   │   ├── client.ts
+│   │   └── index.ts
+│   └── ...                    # Your frontend code
 ├── dist/                      # Built site files (for deployment)
 └── package.json
 ```

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 import { EventEmitter, addAbortListener, on, once, setMaxListeners } from "node:events";
 import childProcess, { ChildProcess, execFile, spawn, spawnSync } from "node:child_process";
-import path, { basename, dirname, join, posix, resolve, win32 } from "node:path";
+import path, { basename, dirname, join, posix, relative, resolve, win32 } from "node:path";
 import fs, { appendFileSync, createReadStream, createWriteStream, readFileSync, statSync, writeFileSync } from "node:fs";
 import y, { execArgv, execPath, hrtime, platform, stdin, stdout } from "node:process";
 import { aborted, callbackify, debuglog, inspect, promisify, stripVTControlCharacters } from "node:util";
@@ -4547,7 +4547,6 @@ const string$1 = (params) => {
 };
 const integer = /^-?\d+$/;
 const number$1 = /^-?\d+(?:\.\d+)?$/;
-const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 
@@ -5326,24 +5325,6 @@ const $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst,
 	$ZodCheckNumberFormat.init(inst, def);
 	$ZodNumber.init(inst, def);
 });
-const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
-	$ZodType.init(inst, def);
-	inst._zod.pattern = boolean$1;
-	inst._zod.parse = (payload, _ctx) => {
-		if (def.coerce) try {
-			payload.value = Boolean(payload.value);
-		} catch (_$2) {}
-		const input = payload.value;
-		if (typeof input === "boolean") return payload;
-		payload.issues.push({
-			expected: "boolean",
-			code: "invalid_type",
-			input,
-			inst
-		});
-		return payload;
-	};
-});
 const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -5819,6 +5800,97 @@ function handleTupleResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject$1(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[key] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number")) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[keyResult.value] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -5837,6 +5909,24 @@ const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 		return payload;
 	};
 });
+const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
+	const values = new Set(def.values);
+	inst._zod.values = values;
+	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${def.values.map((o$2) => typeof o$2 === "string" ? escapeRegex(o$2) : o$2 ? escapeRegex(o$2.toString()) : String(o$2)).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (values.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values: def.values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -6398,13 +6488,6 @@ function _int(Class, params) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
-function _boolean(Class, params) {
-	return new Class({
-		type: "boolean",
-		...normalizeParams(params)
-	});
-}
-/* @__NO_SIDE_EFFECTS__ */
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -6975,9 +7058,6 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 	}
 	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
 };
-const booleanProcessor = (_schema, _ctx, json, _params) => {
-	json.type = "boolean";
-};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -6989,6 +7069,27 @@ const enumProcessor = (schema, _ctx, json, _params) => {
 	if (values.every((v$1) => typeof v$1 === "string")) json.type = "string";
 	json.enum = values;
 };
+const literalProcessor = (schema, ctx, json, _params) => {
+	const def = schema._zod.def;
+	const vals = [];
+	for (const val of def.values) if (val === void 0) {
+		if (ctx.unrepresentable === "throw") throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+	} else if (typeof val === "bigint") if (ctx.unrepresentable === "throw") throw new Error("BigInt literals cannot be represented in JSON Schema");
+	else vals.push(Number(val));
+	else vals.push(val);
+	if (vals.length === 0) {} else if (vals.length === 1) {
+		const val = vals[0];
+		json.type = val === null ? "null" : typeof val;
+		if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") json.enum = [val];
+		else json.const = val;
+	} else {
+		if (vals.every((v$1) => typeof v$1 === "number")) json.type = "number";
+		if (vals.every((v$1) => typeof v$1 === "string")) json.type = "string";
+		if (vals.every((v$1) => typeof v$1 === "boolean")) json.type = "boolean";
+		if (vals.every((v$1) => v$1 === null)) json.type = "null";
+		json.enum = vals;
+	}
+};
 const customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
@@ -7109,6 +7210,39 @@ const tupleProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process$2(def.valueType, ctx, {
+			...params,
+			path: [
+				...params.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		json.patternProperties = {};
+		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
+	} else {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$2(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json.additionalProperties = process$2(def.valueType, ctx, {
+			...params,
+			path: [...params.path, "additionalProperties"]
+		});
+	}
+	const keyValues = keyType._zod.values;
+	if (keyValues) {
+		const validKeyValues = [...keyValues].filter((v$1) => typeof v$1 === "string" || typeof v$1 === "number");
+		if (validKeyValues.length > 0) json.required = validKeyValues;
+	}
+};
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = process$2(def.innerType, ctx, params);
@@ -7501,14 +7635,6 @@ const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, d
 function int(params) {
 	return _int(ZodNumberFormat, params);
 }
-const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
-	$ZodBoolean.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
-});
-function boolean(params) {
-	return _boolean(ZodBoolean, params);
-}
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -7638,6 +7764,21 @@ function tuple(items, _paramsOrRest, _params) {
 		...normalizeParams(params)
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -7675,6 +7816,23 @@ function _enum(values, params) {
 		...normalizeParams(params)
 	});
 }
+const ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
+	inst.values = new Set(def.values);
+	Object.defineProperty(inst, "value", { get() {
+		if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+		return def.values[0];
+	} });
+});
+function literal(value, params) {
+	return new ZodLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
+		...normalizeParams(params)
+	});
+}
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
@@ -7900,19 +8058,6 @@ var AuthValidationError = class extends Error {
 		this.name = "AuthValidationError";
 	}
 };
-var ConnectorApiError = class extends Error {
-	constructor(message, cause) {
-		super(message);
-		this.cause = cause;
-		this.name = "ConnectorApiError";
-	}
-};
-var ConnectorValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ConnectorValidationError";
-	}
-};
 
 //#endregion
 //#region src/core/consts.ts
@@ -13637,10 +13782,10 @@ var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.removeDuplicateSlashes = removeDuplicateSlashes;
 	function partitionAbsoluteAndRelative(patterns) {
 		const absolute = [];
-		const relative = [];
+		const relative$1 = [];
 		for (const pattern of patterns) if (isAbsolute(pattern)) absolute.push(pattern);
-		else relative.push(pattern);
-		return [absolute, relative];
+		else relative$1.push(pattern);
+		return [absolute, relative$1];
 	}
 	exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
 	function isAbsolute(pattern) {
@@ -28065,7 +28210,7 @@ const FILE$1 = Symbol("file");
 const DIRECTORY$1 = Symbol("directory");
 const SYMLINK$1 = Symbol("symlink");
 const HARDLINK$1 = Symbol("hardlink");
-const HEADER = Symbol("header");
+const HEADER$1 = Symbol("header");
 const READ = Symbol("read");
 const LSTAT = Symbol("lstat");
 const ONLSTAT = Symbol("onlstat");
@@ -28184,7 +28329,7 @@ var WriteEntry = class extends Minipass {
 	[PREFIX](path$16) {
 		return prefixPath(path$16, this.prefix);
 	}
-	[HEADER]() {
+	[HEADER$1]() {
 		/* c8 ignore start */
 		if (!this.stat) throw new Error("cannot write header before stat");
 		/* c8 ignore stop */
@@ -28229,7 +28374,7 @@ var WriteEntry = class extends Minipass {
 		/* c8 ignore stop */
 		if (this.path.slice(-1) !== "/") this.path += "/";
 		this.stat.size = 0;
-		this[HEADER]();
+		this[HEADER$1]();
 		this.end();
 	}
 	[SYMLINK$1]() {
@@ -28240,7 +28385,7 @@ var WriteEntry = class extends Minipass {
 	}
 	[ONREADLINK](linkpath) {
 		this.linkpath = normalizeWindowsPath(linkpath);
-		this[HEADER]();
+		this[HEADER$1]();
 		this.end();
 	}
 	[HARDLINK$1](linkpath) {
@@ -28250,7 +28395,7 @@ var WriteEntry = class extends Minipass {
 		this.type = "Link";
 		this.linkpath = normalizeWindowsPath(path$1.relative(this.cwd, linkpath));
 		this.stat.size = 0;
-		this[HEADER]();
+		this[HEADER$1]();
 		this.end();
 	}
 	[FILE$1]() {
@@ -28263,7 +28408,7 @@ var WriteEntry = class extends Minipass {
 			if (linkpath?.indexOf(this.cwd) === 0) return this[HARDLINK$1](linkpath);
 			this.linkCache.set(linkKey, this.absolute);
 		}
-		this[HEADER]();
+		this[HEADER$1]();
 		if (this.stat.size === 0) return this.end();
 		this[OPENFILE]();
 	}
@@ -31005,10 +31150,7 @@ const theme = {
 		base44OrangeBackground: source_default.bgHex("#E86B3C"),
 		shinyOrange: source_default.hex("#FFD700"),
 		links: source_default.hex("#00D4FF"),
-		white: source_default.white,
-		success: source_default.green,
-		warning: source_default.yellow,
-		error: source_default.red
+		white: source_default.white
 	},
 	styles: {
 		header: source_default.dim,
@@ -31319,6 +31461,237 @@ const logoutCommand = new Command("logout").description("Logout from current dev
 	await runCommand(logout, { requireAppConfig: false });
 });
 
+//#endregion
+//#region src/core/types/schema.ts
+/**
+* Schema for a full entity definition
+* Uses loose validation to allow JSON Schema flexibility
+*/
+const EntityDefinitionSchema = object({
+	name: string().min(1, "Entity name cannot be empty"),
+	type: literal("object").optional(),
+	properties: record(string(), unknown()).optional(),
+	required: array(string()).optional()
+}).passthrough();
+
+//#endregion
+//#region src/core/types/generator.ts
+const HEADER = `// Auto-generated by Base44 CLI - DO NOT EDIT
+// Regenerate with: base44 types
+`;
+/**
+* Convert a JSON Schema type to TypeScript type
+*/
+function fieldToTypeScript(field, required$1) {
+	let tsType;
+	if (field.enum && field.enum.length > 0) tsType = field.enum.map((v$1) => `'${v$1}'`).join(" | ");
+	else switch (field.type) {
+		case "string":
+			tsType = "string";
+			break;
+		case "number":
+			tsType = "number";
+			break;
+		case "boolean":
+			tsType = "boolean";
+			break;
+		case "array":
+			if (field.items) tsType = `${fieldToTypeScript(field.items, true)}[]`;
+			else tsType = "unknown[]";
+			break;
+		case "object":
+			if (field.properties) tsType = `{ ${Object.entries(field.properties).map(([name$1, prop]) => {
+				const isRequired = field.required?.includes(name$1) ?? false;
+				const propType = fieldToTypeScript(prop, isRequired);
+				return `${name$1}${isRequired ? "" : "?"}: ${propType}`;
+			}).join("; ")} }`;
+			else tsType = "Record<string, unknown>";
+			break;
+		default: tsType = "unknown";
+	}
+	return tsType;
+}
+/**
+* Generate interface fields for an entity
+*/
+function generateInterfaceFields(entity, options = {}) {
+	if (!entity.properties) return "";
+	const requiredFields = new Set(entity.required ?? []);
+	return Object.entries(entity.properties).map(([fieldName, field]) => {
+		const isRequired = options.allOptional ? false : requiredFields.has(fieldName);
+		const tsType = fieldToTypeScript(field, isRequired);
+		const optional$1 = isRequired ? "" : "?";
+		return `${field.description ? `  /** ${field.description} */\n` : ""}  ${fieldName}${optional$1}: ${tsType};`;
+	}).join("\n");
+}
+/**
+* Generate TypeScript interfaces for a single entity
+*/
+function generateEntityTypes(entity) {
+	const name$1 = entity.name;
+	return `
+/** ${name$1} entity */
+export interface ${name$1} extends BaseEntity {
+${generateInterfaceFields(entity)}
+}
+
+/** Input for creating a ${name$1} */
+export interface ${name$1}CreateInput {
+${generateInterfaceFields(entity)}
+}
+
+/** Input for updating a ${name$1} (all fields optional) */
+export interface ${name$1}UpdateInput {
+${generateInterfaceFields(entity, { allOptional: true })}
+}
+
+/** Filter query for ${name$1} */
+export interface ${name$1}Filter {
+${generateInterfaceFields(entity, { allOptional: true })}
+}
+`;
+}
+/**
+* Generate the entities.ts file content
+*/
+function generateEntitiesFile(entities) {
+	const baseEntity = `
+/** System fields present on all entities */
+export interface BaseEntity {
+  id: string;
+  created_date: string;
+  updated_date: string;
+}
+`;
+	const entityTypes = entities.map(generateEntityTypes).join("\n");
+	const entityNames = entities.map((e$1) => `'${e$1.name}'`).join(" | ");
+	const entityNamesType = entities.length > 0 ? `\n/** All entity names in this project */\nexport type EntityName = ${entityNames};\n` : "";
+	return HEADER + baseEntity + entityTypes + entityNamesType;
+}
+/**
+* Generate the client.ts file content with typed SDK wrapper
+*/
+function generateClientFile(entities) {
+	if (entities.length === 0) return HEADER + "\n// No entities found\nexport {};\n";
+	return `${HEADER}
+import type {
+  ${entities.map((e$1) => `${e$1.name}, ${e$1.name}CreateInput, ${e$1.name}UpdateInput, ${e$1.name}Filter`).join(",\n  ")}
+} from './entities.js';
+
+/** Response for list/filter operations */
+export interface ListResponse<T> {
+  items: T[];
+  total: number;
+}
+
+/** Real-time subscription event */
+export interface RealtimeEvent<T> {
+  type: 'create' | 'update' | 'delete';
+  data: T;
+  id: string;
+  timestamp: string;
+}
+
+/** Entity handler with CRUD operations */
+export interface EntityHandler<T, TCreate, TUpdate, TFilter> {
+  /** Get all records with optional pagination */
+  list(sort?: string, limit?: number, skip?: number, fields?: (keyof T)[]): Promise<ListResponse<T>>;
+  /** Get records matching filter criteria */
+  filter(query: TFilter, sort?: string, limit?: number, skip?: number, fields?: (keyof T)[]): Promise<ListResponse<T>>;
+  /** Get a single record by ID */
+  get(id: string): Promise<T>;
+  /** Create a new record */
+  create(data: TCreate): Promise<T>;
+  /** Update an existing record */
+  update(id: string, data: TUpdate): Promise<T>;
+  /** Delete a record */
+  delete(id: string): Promise<void>;
+  /** Delete multiple records matching filter */
+  deleteMany(query: TFilter): Promise<void>;
+  /** Create multiple records at once */
+  bulkCreate(data: TCreate[]): Promise<T[]>;
+  /** Subscribe to real-time updates */
+  subscribe(callback: (event: RealtimeEvent<T>) => void): () => void;
+}
+
+/** Typed entities interface for Base44 SDK */
+export interface TypedEntities {
+${entities.map((e$1) => `  ${e$1.name}: EntityHandler<${e$1.name}, ${e$1.name}CreateInput, ${e$1.name}UpdateInput, ${e$1.name}Filter>;`).join("\n")}
+}
+
+/**
+ * Typed Base44 client interface.
+ * Use with the Base44 SDK for type-safe entity access.
+ *
+ * @example
+ * import { createClient } from '@base44/sdk';
+ * import type { TypedBase44Client } from './base44/client';
+ *
+ * const base44 = createClient({ appId: 'your-app-id' }) as TypedBase44Client;
+ * const tasks = await base44.entities.Task.list();
+ */
+export interface TypedBase44Client {
+  entities: TypedEntities;
+}
+`;
+}
+/**
+* Generate the index.ts barrel file
+*/
+function generateIndexFile() {
+	return `${HEADER}
+export * from './entities.js';
+export * from './client.js';
+`;
+}
+
+//#endregion
+//#region src/core/types/types.ts
+/**
+* Parse entities into EntityDefinition format for type generation
+*/
+function parseEntities(entities) {
+	return entities.map((entity) => {
+		const result = EntityDefinitionSchema.safeParse(entity);
+		if (result.success) return result.data;
+		const entityName = entity.name ?? "unknown";
+		console.warn(`Skipping invalid entity "${entityName}": ${result.error.issues.map((i$1) => `${i$1.path.join(".")}: ${i$1.message}`).join(", ")}`);
+		return null;
+	}).filter((e$1) => e$1 !== null);
+}
+/**
+* Generate TypeScript types from local entity schemas
+*/
+async function generateTypes(options = {}) {
+	const { output = "src/base44", entitiesOnly = false } = options;
+	const projectRoot = await findProjectRoot();
+	if (!projectRoot) throw new Error("Project root not found. Please run this command from within a Base44 project.");
+	const { entities } = await readProjectConfig(projectRoot.root);
+	const parsedEntities = parseEntities(entities);
+	const outputDir = join(projectRoot.root, output);
+	await mkdir(outputDir, { recursive: true });
+	const files = [];
+	const entitiesContent = generateEntitiesFile(parsedEntities);
+	const entitiesPath = join(outputDir, "entities.ts");
+	await writeFile(entitiesPath, entitiesContent, "utf-8");
+	files.push(entitiesPath);
+	if (!entitiesOnly) {
+		const clientContent = generateClientFile(parsedEntities);
+		const clientPath = join(outputDir, "client.ts");
+		await writeFile(clientPath, clientContent, "utf-8");
+		files.push(clientPath);
+		const indexContent = generateIndexFile();
+		const indexPath = join(outputDir, "index.ts");
+		await writeFile(indexPath, indexContent, "utf-8");
+		files.push(indexPath);
+	}
+	return {
+		entityCount: parsedEntities.length,
+		files,
+		outputDir
+	};
+}
+
 //#endregion
 //#region src/cli/commands/entities/push.ts
 async function pushEntitiesAction() {
@@ -31364,6 +31737,35 @@ const functionsDeployCommand = new Command("functions").description("Manage proj
 	await runCommand(deployFunctionsAction, { requireAuth: true });
 }));
 
+//#endregion
+//#region src/cli/commands/types/generate.ts
+async function generateTypesAction(options) {
+	const result = await runTask("Generating TypeScript types", async () => {
+		return await generateTypes({
+			output: options.output,
+			entitiesOnly: options.entitiesOnly
+		});
+	}, {
+		successMessage: "Types generated successfully",
+		errorMessage: "Failed to generate types"
+	});
+	if (result.entityCount === 0) {
+		M.warn("No entities found in project");
+		return { outroMessage: "No types generated" };
+	}
+	M.info(`Generated types for ${result.entityCount} entities`);
+	M.info(`Output directory: ${result.outputDir}`);
+	const fileList = result.files.map((f) => `  - ${relative(process.cwd(), f)}`).join("\n");
+	M.info(`Files:\n${fileList}`);
+	return { outroMessage: "Types generated successfully!" };
+}
+const typesGenerateCommand = new Command("types").description("Generate TypeScript types from entity schemas").option("-o, --output <dir>", "Output directory", "src/base44").option("--entities-only", "Only generate entity types, skip client types").action(async (options) => {
+	await runCommand(() => generateTypesAction(options), {
+		requireAuth: false,
+		requireAppConfig: false
+	});
+});
+
 //#endregion
 //#region node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
@@ -38842,390 +39244,6 @@ const siteDeployCommand = new Command("site").description("Manage site deploymen
 	await runCommand(() => deployAction(options), { requireAuth: true });
 }));
 
-//#endregion
-//#region src/core/connectors/schema.ts
-/**
-* Response from POST /api/apps/{app_id}/external-auth/initiate
-*/
-const InitiateResponseSchema = object({
-	redirect_url: string().optional(),
-	connection_id: string().optional(),
-	already_authorized: boolean().optional(),
-	other_user_email: string().optional(),
-	error: string().optional()
-});
-/**
-* Response from GET /api/apps/{app_id}/external-auth/status
-*/
-const StatusResponseSchema = object({
-	status: _enum([
-		"ACTIVE",
-		"PENDING",
-		"FAILED"
-	]),
-	account_email: string().optional(),
-	error: string().optional()
-});
-/**
-* A connected integration from the list endpoint
-*/
-const ConnectorSchema = object({
-	integration_type: string(),
-	status: string(),
-	connected_at: string().optional(),
-	account_info: object({
-		email: string().optional(),
-		name: string().optional()
-	}).optional()
-}).transform((data) => ({
-	integrationType: data.integration_type,
-	status: data.status,
-	connectedAt: data.connected_at,
-	accountInfo: data.account_info
-}));
-/**
-* Response from GET /api/apps/{app_id}/external-auth/list
-*/
-const ListResponseSchema = object({ integrations: array(ConnectorSchema) });
-/**
-* Generic API error response
-*/
-const ApiErrorSchema = object({
-	error: string(),
-	detail: string().optional()
-});
-
-//#endregion
-//#region src/core/connectors/api.ts
-/**
-* Initiates OAuth flow for a connector integration.
-* Returns a redirect URL to open in the browser.
-*/
-async function initiateOAuth(integrationType, scopes = null) {
-	const response = await getAppClient().post("external-auth/initiate", {
-		json: {
-			integration_type: integrationType,
-			scopes
-		},
-		throwHttpErrors: false
-	});
-	const json = await response.json();
-	if (!response.ok) {
-		const errorResult = ApiErrorSchema.safeParse(json);
-		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
-		throw new ConnectorApiError(`Failed to initiate OAuth: ${response.status} ${response.statusText}`);
-	}
-	const result = InitiateResponseSchema.safeParse(json);
-	if (!result.success) throw new ConnectorValidationError(`Invalid initiate response from server: ${result.error.message}`);
-	return result.data;
-}
-/**
-* Checks the status of an OAuth connection attempt.
-*/
-async function checkOAuthStatus(integrationType, connectionId) {
-	const response = await getAppClient().get("external-auth/status", {
-		searchParams: {
-			integration_type: integrationType,
-			connection_id: connectionId
-		},
-		throwHttpErrors: false
-	});
-	const json = await response.json();
-	if (!response.ok) {
-		const errorResult = ApiErrorSchema.safeParse(json);
-		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
-		throw new ConnectorApiError(`Failed to check OAuth status: ${response.status} ${response.statusText}`);
-	}
-	const result = StatusResponseSchema.safeParse(json);
-	if (!result.success) throw new ConnectorValidationError(`Invalid status response from server: ${result.error.message}`);
-	return result.data;
-}
-/**
-* Lists all connected integrations for the current app.
-*/
-async function listConnectors() {
-	const response = await getAppClient().get("external-auth/list", { throwHttpErrors: false });
-	const json = await response.json();
-	if (!response.ok) {
-		const errorResult = ApiErrorSchema.safeParse(json);
-		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
-		throw new ConnectorApiError(`Failed to list connectors: ${response.status} ${response.statusText}`);
-	}
-	const result = ListResponseSchema.safeParse(json);
-	if (!result.success) throw new ConnectorValidationError(`Invalid list response from server: ${result.error.message}`);
-	return result.data.integrations;
-}
-/**
-* Disconnects (soft delete) a connector integration.
-*/
-async function disconnectConnector(integrationType) {
-	const response = await getAppClient().delete(`external-auth/integrations/${integrationType}`, { throwHttpErrors: false });
-	if (!response.ok) {
-		const json = await response.json();
-		const errorResult = ApiErrorSchema.safeParse(json);
-		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
-		throw new ConnectorApiError(`Failed to disconnect connector: ${response.status} ${response.statusText}`);
-	}
-}
-
-//#endregion
-//#region src/core/connectors/constants.ts
-/**
-* Supported OAuth connector integrations.
-* Based on apper/backend/app/external_auth/models/constants.py
-*/
-const SUPPORTED_INTEGRATIONS = [
-	"googlecalendar",
-	"googledrive",
-	"gmail",
-	"googlesheets",
-	"googledocs",
-	"googleslides",
-	"slack",
-	"notion",
-	"salesforce",
-	"hubspot",
-	"linkedin",
-	"tiktok"
-];
-/**
-* Display names for integrations (for CLI output)
-*/
-const INTEGRATION_DISPLAY_NAMES = {
-	googlecalendar: "Google Calendar",
-	googledrive: "Google Drive",
-	gmail: "Gmail",
-	googlesheets: "Google Sheets",
-	googledocs: "Google Docs",
-	googleslides: "Google Slides",
-	slack: "Slack",
-	notion: "Notion",
-	salesforce: "Salesforce",
-	hubspot: "HubSpot",
-	linkedin: "LinkedIn",
-	tiktok: "TikTok"
-};
-function isValidIntegration(type) {
-	return SUPPORTED_INTEGRATIONS.includes(type);
-}
-function getIntegrationDisplayName(type) {
-	if (isValidIntegration(type)) return INTEGRATION_DISPLAY_NAMES[type];
-	return type;
-}
-
-//#endregion
-//#region src/cli/commands/connectors/add.ts
-const POLL_INTERVAL_MS = 2e3;
-const POLL_TIMEOUT_MS = 300 * 1e3;
-async function promptForIntegrationType() {
-	const selected = await ve({
-		message: "Select an integration to connect:",
-		options: SUPPORTED_INTEGRATIONS.map((type) => ({
-			value: type,
-			label: getIntegrationDisplayName(type)
-		}))
-	});
-	if (pD(selected)) return null;
-	return selected;
-}
-async function waitForOAuthCompletion(integrationType, connectionId) {
-	let accountEmail;
-	let error;
-	try {
-		await runTask("Waiting for authorization...", async (updateMessage) => {
-			await pWaitFor(async () => {
-				const status = await checkOAuthStatus(integrationType, connectionId);
-				if (status.status === "ACTIVE") {
-					accountEmail = status.account_email;
-					return true;
-				}
-				if (status.status === "FAILED") {
-					error = status.error || "Authorization failed";
-					throw new Error(error);
-				}
-				updateMessage("Waiting for authorization in browser...");
-				return false;
-			}, {
-				interval: POLL_INTERVAL_MS,
-				timeout: POLL_TIMEOUT_MS
-			});
-		}, {
-			successMessage: "Authorization completed!",
-			errorMessage: "Authorization failed"
-		});
-		return {
-			success: true,
-			accountEmail
-		};
-	} catch (err) {
-		if (err instanceof Error && err.message.includes("timed out")) return {
-			success: false,
-			error: "Authorization timed out. Please try again."
-		};
-		return {
-			success: false,
-			error: error || (err instanceof Error ? err.message : "Unknown error")
-		};
-	}
-}
-async function addConnector(integrationType) {
-	let selectedType;
-	if (!integrationType) {
-		const prompted = await promptForIntegrationType();
-		if (!prompted) return { outroMessage: "Cancelled" };
-		selectedType = prompted;
-	} else {
-		if (!isValidIntegration(integrationType)) {
-			const supportedList = SUPPORTED_INTEGRATIONS.join(", ");
-			throw new Error(`Unsupported connector: ${integrationType}\nSupported connectors: ${supportedList}`);
-		}
-		selectedType = integrationType;
-	}
-	const displayName = getIntegrationDisplayName(selectedType);
-	const initiateResponse = await runTask(`Initiating ${displayName} connection...`, async () => {
-		return await initiateOAuth(selectedType);
-	}, {
-		successMessage: `${displayName} OAuth initiated`,
-		errorMessage: `Failed to initiate ${displayName} connection`
-	});
-	if (initiateResponse.already_authorized) return { outroMessage: `Already connected to ${theme.styles.bold(displayName)}` };
-	if (initiateResponse.error === "different_user" && initiateResponse.other_user_email) throw new Error(`This app is already connected to ${displayName} by ${initiateResponse.other_user_email}`);
-	if (!initiateResponse.redirect_url || !initiateResponse.connection_id) throw new Error("Invalid response from server: missing redirect URL or connection ID");
-	M.info(`Opening browser for ${displayName} authorization...`);
-	await open_default(initiateResponse.redirect_url);
-	const result = await waitForOAuthCompletion(selectedType, initiateResponse.connection_id);
-	if (!result.success) throw new Error(result.error || "Authorization failed");
-	const accountInfo = result.accountEmail ? ` as ${theme.styles.bold(result.accountEmail)}` : "";
-	return { outroMessage: `Successfully connected to ${theme.styles.bold(displayName)}${accountInfo}` };
-}
-const connectorsAddCommand = new Command("connectors:add").argument("[type]", "Integration type (e.g., slack, notion, googlecalendar)").description("Connect an OAuth integration").action(async (type) => {
-	await runCommand(() => addConnector(type), {
-		requireAuth: true,
-		requireAppConfig: true
-	});
-});
-
-//#endregion
-//#region src/cli/commands/connectors/list.ts
-function formatDate(dateString) {
-	if (!dateString) return "-";
-	try {
-		return new Date(dateString).toLocaleDateString("en-US", {
-			year: "numeric",
-			month: "short",
-			day: "numeric"
-		});
-	} catch {
-		return dateString;
-	}
-}
-function formatStatus(status) {
-	const normalized = status.toLowerCase();
-	if (normalized === "active" || normalized === "connected") return theme.colors.success("● active");
-	if (normalized === "expired") return theme.colors.warning("● expired");
-	if (normalized === "failed" || normalized === "disconnected") return theme.colors.error("● disconnected");
-	return status;
-}
-async function listConnectorsCommand() {
-	const connectors = await runTask("Fetching connectors...", async () => {
-		return await listConnectors();
-	}, {
-		successMessage: "Connectors loaded",
-		errorMessage: "Failed to fetch connectors"
-	});
-	if (connectors.length === 0) {
-		M.info("No connectors configured for this app.");
-		M.info(`Run ${theme.styles.bold("base44 connectors:add")} to connect an integration.`);
-		return { outroMessage: "" };
-	}
-	console.log();
-	console.log(theme.styles.bold("Connected Integrations:"));
-	console.log();
-	const headers = [
-		"Type",
-		"Account",
-		"Status",
-		"Connected"
-	];
-	const colWidths = [
-		20,
-		30,
-		15,
-		15
-	];
-	const headerRow = headers.map((h$2, i$1) => h$2.padEnd(colWidths[i$1])).join(" ");
-	console.log(theme.styles.dim(headerRow));
-	console.log(theme.styles.dim("─".repeat(headerRow.length)));
-	for (const connector of connectors) {
-		const type = getIntegrationDisplayName(connector.integrationType).padEnd(colWidths[0]);
-		const account = (connector.accountInfo?.email || connector.accountInfo?.name || "-").padEnd(colWidths[1]);
-		const status = formatStatus(connector.status);
-		const connected = formatDate(connector.connectedAt).padEnd(colWidths[3]);
-		console.log(`${type} ${account} ${status.padEnd(colWidths[2] + 10)} ${connected}`);
-	}
-	console.log();
-	return { outroMessage: `${connectors.length} connector${connectors.length === 1 ? "" : "s"} configured` };
-}
-const connectorsListCommand = new Command("connectors:list").description("List all connected OAuth integrations").action(async () => {
-	await runCommand(listConnectorsCommand, {
-		requireAuth: true,
-		requireAppConfig: true
-	});
-});
-
-//#endregion
-//#region src/cli/commands/connectors/remove.ts
-async function promptForConnectorToRemove(connectors) {
-	const selected = await ve({
-		message: "Select a connector to remove:",
-		options: connectors.map((c$1) => ({
-			value: c$1.integrationType,
-			label: `${getIntegrationDisplayName(c$1.integrationType)}${c$1.accountInfo?.email ? ` (${c$1.accountInfo.email})` : ""}`
-		}))
-	});
-	if (pD(selected)) return null;
-	return selected;
-}
-async function removeConnectorCommand(integrationType) {
-	const connectors = await runTask("Fetching connectors...", async () => {
-		return await listConnectors();
-	}, {
-		successMessage: "Connectors loaded",
-		errorMessage: "Failed to fetch connectors"
-	});
-	if (connectors.length === 0) return { outroMessage: "No connectors to remove" };
-	let selectedType;
-	if (!integrationType) {
-		const prompted = await promptForConnectorToRemove(connectors);
-		if (!prompted) return { outroMessage: "Cancelled" };
-		selectedType = prompted;
-	} else {
-		if (!isValidIntegration(integrationType)) throw new Error(`Invalid connector type: ${integrationType}`);
-		if (!connectors.some((c$1) => c$1.integrationType === integrationType)) throw new Error(`No ${getIntegrationDisplayName(integrationType)} connector found for this app`);
-		selectedType = integrationType;
-	}
-	const displayName = getIntegrationDisplayName(selectedType);
-	const connector = connectors.find((c$1) => c$1.integrationType === selectedType);
-	const shouldRemove = await ye({
-		message: `Disconnect ${displayName}${connector?.accountInfo?.email ? ` (${connector.accountInfo.email})` : ""}?`,
-		initialValue: false
-	});
-	if (pD(shouldRemove) || !shouldRemove) return { outroMessage: "Cancelled" };
-	await runTask(`Disconnecting ${displayName}...`, async () => {
-		await disconnectConnector(selectedType);
-	}, {
-		successMessage: `${displayName} disconnected`,
-		errorMessage: `Failed to disconnect ${displayName}`
-	});
-	return { outroMessage: `Successfully disconnected ${theme.styles.bold(displayName)}` };
-}
-const connectorsRemoveCommand = new Command("connectors:remove").argument("[type]", "Integration type to remove (e.g., slack, notion)").description("Disconnect an OAuth integration").action(async (type) => {
-	await runCommand(() => removeConnectorCommand(type), {
-		requireAuth: true,
-		requireAppConfig: true
-	});
-});
-
 //#endregion
 //#region package.json
 var version = "0.0.15";
@@ -39244,10 +39262,8 @@ program.addCommand(deployCommand);
 program.addCommand(linkCommand);
 program.addCommand(entitiesPushCommand);
 program.addCommand(functionsDeployCommand);
+program.addCommand(typesGenerateCommand);
 program.addCommand(siteDeployCommand);
-program.addCommand(connectorsAddCommand);
-program.addCommand(connectorsListCommand);
-program.addCommand(connectorsRemoveCommand);
 program.parse();
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.15-pr.100.7c491cf",
+  "version": "0.0.15-pr.102.ec2ad29",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "main": "./dist/cli/index.js",