@base44-preview/cli 0.0.32-pr.257.4ffcf9d → 0.0.32-pr.259.1042e3a

package/dist/cli/index.js

@@ -185505,6 +185505,118 @@ async function pushEntities(entities) {
   }
   return syncEntities(entities);
 }
+// src/core/resources/entity/records-schema.ts
+var EntityRecordSchema = exports_external.object({
+  id: exports_external.string(),
+  created_date: exports_external.string(),
+  updated_date: exports_external.string(),
+  created_by: exports_external.string().optional()
+}).passthrough();
+var DeleteRecordResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+
+// src/core/resources/entity/records-api.ts
+async function listRecords(entityName, options = {}) {
+  const appClient = getAppClient();
+  const searchParams = new URLSearchParams;
+  if (options.filter) {
+    searchParams.set("q", options.filter);
+  }
+  if (options.sort) {
+    searchParams.set("sort", options.sort);
+  }
+  if (options.limit !== undefined) {
+    searchParams.set("limit", String(options.limit));
+  }
+  if (options.skip !== undefined) {
+    searchParams.set("skip", String(options.skip));
+  }
+  if (options.fields) {
+    searchParams.set("fields", options.fields);
+  }
+  let response;
+  try {
+    response = await appClient.get(`admin/entities/${entityName}`, {
+      searchParams
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing records");
+  }
+  const json2 = await response.json();
+  const records = Array.isArray(json2) ? json2 : [];
+  return records.map((record2) => {
+    const result = EntityRecordSchema.safeParse(record2);
+    if (!result.success) {
+      throw new SchemaValidationError("Invalid record in response", result.error);
+    }
+    return result.data;
+  });
+}
+async function getRecord(entityName, recordId) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get(`admin/entities/${entityName}/${recordId}`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "getting record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record response", result.error);
+  }
+  return result.data;
+}
+async function createRecord(entityName, data) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.post(`admin/entities/${entityName}`, {
+      json: data
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "creating record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record in create response", result.error);
+  }
+  return result.data;
+}
+async function updateRecord(entityName, recordId, data) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.put(`admin/entities/${entityName}/${recordId}`, {
+      json: data
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "updating record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record in update response", result.error);
+  }
+  return result.data;
+}
+async function deleteRecord(entityName, recordId) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.delete(`admin/entities/${entityName}/${recordId}`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "deleting record");
+  }
+  const json2 = await response.json();
+  const result = DeleteRecordResponseSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid delete response", result.error);
+  }
+  return result.data;
+}
 // src/core/resources/entity/resource.ts
 var entityResource = {
   readAll: readAllEntities,
@@ -194574,9 +194686,185 @@ async function pushEntitiesAction() {
   return { outroMessage: "Entities pushed to Base44" };
 }
 function getEntitiesPushCommand(context) {
-  return new Command("entities").description("Manage project entities").addCommand(new Command("push").description("Push local entities to Base44").action(async () => {
+  return new Command("push").description("Push local entity schemas to Base44").action(async () => {
     await runCommand(pushEntitiesAction, { requireAuth: true }, context);
-  }));
+  });
+}
+
+// src/cli/commands/entities/records/create.ts
+var import_json52 = __toESM(require_lib(), 1);
+async function parseRecordData(options) {
+  if (options.data) {
+    try {
+      return import_json52.default.parse(options.data);
+    } catch {
+      throw new InvalidInputError("Invalid JSON in --data flag. Provide valid JSON.", {
+        hints: [
+          {
+            message: `Example: --data '{"name": "John", "email": "john@example.com"}'`
+          }
+        ]
+      });
+    }
+  }
+  if (options.file) {
+    const content = await readTextFile(options.file);
+    try {
+      return import_json52.default.parse(content);
+    } catch {
+      throw new InvalidInputError(`Invalid JSON in file ${options.file}. Provide a valid JSON/JSONC file.`);
+    }
+  }
+  throw new InvalidInputError("Provide record data with --data or --file flag", {
+    hints: [
+      {
+        message: `Example: --data '{"name": "John"}' or --file record.json`
+      }
+    ]
+  });
+}
+async function createRecordAction(entityName, options) {
+  const data = await parseRecordData(options);
+  const record2 = await runTask(`Creating ${entityName} record...`, async () => {
+    return await createRecord(entityName, data);
+  }, {
+    successMessage: `Created ${entityName} record`,
+    errorMessage: `Failed to create ${entityName} record`
+  });
+  M2.success(`Record created with ID: ${record2.id}`);
+  console.log(JSON.stringify(record2, null, 2));
+  return {};
+}
+function getRecordsCreateCommand(context) {
+  return new Command("create").description("Create a new entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").option("-d, --data <json>", "JSON object with record data").option("--file <path>", "Read record data from a JSON/JSONC file").action(async (entityName, options) => {
+    await runCommand(() => createRecordAction(entityName, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/delete.ts
+async function deleteRecordAction(entityName, recordId, options) {
+  if (!options.yes) {
+    const confirmed = await ye({
+      message: `Delete ${entityName} record ${recordId}?`
+    });
+    if (confirmed !== true) {
+      throw new CLIExitError(0);
+    }
+  }
+  await runTask(`Deleting ${entityName} record...`, async () => {
+    return await deleteRecord(entityName, recordId);
+  }, {
+    successMessage: `Deleted ${entityName} record`,
+    errorMessage: `Failed to delete ${entityName} record`
+  });
+  M2.success(`Record ${recordId} deleted`);
+  return {};
+}
+function getRecordsDeleteCommand(context) {
+  return new Command("delete").description("Delete an entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record to delete").option("-y, --yes", "Skip confirmation prompt").action(async (entityName, recordId, options) => {
+    await runCommand(() => deleteRecordAction(entityName, recordId, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/get.ts
+async function getRecordAction(entityName, recordId) {
+  const record2 = await runTask(`Fetching ${entityName} record...`, async () => {
+    return await getRecord(entityName, recordId);
+  }, {
+    successMessage: `Fetched ${entityName} record`,
+    errorMessage: `Failed to fetch ${entityName} record`
+  });
+  console.log(JSON.stringify(record2, null, 2));
+  return {};
+}
+function getRecordsGetCommand(context) {
+  return new Command("get").description("Get a single entity record by ID").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record").action(async (entityName, recordId) => {
+    await runCommand(() => getRecordAction(entityName, recordId), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/list.ts
+async function listRecordsAction(entityName, options) {
+  const records = await runTask(`Fetching ${entityName} records...`, async () => {
+    return await listRecords(entityName, {
+      filter: options.filter,
+      sort: options.sort,
+      limit: options.limit ? Number(options.limit) : 50,
+      skip: options.skip ? Number(options.skip) : undefined,
+      fields: options.fields
+    });
+  }, {
+    successMessage: `Fetched ${entityName} records`,
+    errorMessage: `Failed to fetch ${entityName} records`
+  });
+  M2.info(`Found ${records.length} record(s)`);
+  console.log(JSON.stringify(records, null, 2));
+  return {};
+}
+function getRecordsListCommand(context) {
+  return new Command("list").description("List entity records").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").option("-f, --filter <json>", "JSON query filter").option("-s, --sort <field>", "Sort field (prefix with - for descending)").option("-l, --limit <n>", "Max records to return", "50").option("--skip <n>", "Number of records to skip").option("--fields <fields>", "Comma-separated fields to return").action(async (entityName, options) => {
+    await runCommand(() => listRecordsAction(entityName, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/update.ts
+var import_json53 = __toESM(require_lib(), 1);
+async function parseUpdateData(options) {
+  if (options.data) {
+    try {
+      return import_json53.default.parse(options.data);
+    } catch {
+      throw new InvalidInputError("Invalid JSON in --data flag. Provide valid JSON.", {
+        hints: [
+          {
+            message: `Example: --data '{"status": "active"}'`
+          }
+        ]
+      });
+    }
+  }
+  if (options.file) {
+    const content = await readTextFile(options.file);
+    try {
+      return import_json53.default.parse(content);
+    } catch {
+      throw new InvalidInputError(`Invalid JSON in file ${options.file}. Provide a valid JSON/JSONC file.`);
+    }
+  }
+  throw new InvalidInputError("Provide update data with --data or --file flag", {
+    hints: [
+      {
+        message: `Example: --data '{"status": "active"}' or --file update.json`
+      }
+    ]
+  });
+}
+async function updateRecordAction(entityName, recordId, options) {
+  const data = await parseUpdateData(options);
+  const record2 = await runTask(`Updating ${entityName} record...`, async () => {
+    return await updateRecord(entityName, recordId, data);
+  }, {
+    successMessage: `Updated ${entityName} record`,
+    errorMessage: `Failed to update ${entityName} record`
+  });
+  M2.success(`Record ${recordId} updated`);
+  console.log(JSON.stringify(record2, null, 2));
+  return {};
+}
+function getRecordsUpdateCommand(context) {
+  return new Command("update").description("Update an entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record to update").option("-d, --data <json>", "JSON object with fields to update").option("--file <path>", "Read update data from a JSON/JSONC file").action(async (entityName, recordId, options) => {
+    await runCommand(() => updateRecordAction(entityName, recordId, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/index.ts
+function getRecordsCommand(context) {
+  return new Command("records").description("CRUD operations on entity records").addCommand(getRecordsListCommand(context)).addCommand(getRecordsGetCommand(context)).addCommand(getRecordsCreateCommand(context)).addCommand(getRecordsUpdateCommand(context)).addCommand(getRecordsDeleteCommand(context));
+}
+
+// src/cli/commands/entities/index.ts
+function getEntitiesCommand(context) {
+  return new Command("entities").description("Manage project entities").addCommand(getEntitiesPushCommand(context)).addCommand(getRecordsCommand(context));
 }
 
 // src/cli/commands/functions/deploy.ts
@@ -195484,7 +195772,7 @@ function createProgram(context) {
   program2.addCommand(getDeployCommand(context));
   program2.addCommand(getLinkCommand(context));
   program2.addCommand(getEjectCommand(context));
-  program2.addCommand(getEntitiesPushCommand(context));
+  program2.addCommand(getEntitiesCommand(context));
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsDeployCommand(context));
@@ -199758,4 +200046,4 @@ export {
   CLIExitError
 };
 
-//# debugId=0FDC22A7A382A88A64756E2164756E21
+//# debugId=7988BF189BA90B3464756E2164756E21