zinkee 0.1.32 → 0.1.34

package/README.md

@@ -279,13 +279,16 @@ Notes:
 ### CRUD operations
 
 ```bash
-# Create
+# Create a single record (--set/--set-json/--raw/--raw-file build one record)
 zinkee records create projects \
   --set name="Website Redesign" \
   --set budget=25000 \
   --set start-date="2026-01-15T00:00:00.000Z" \
   --set status=1
 
+# Create many records from a JSON array file (one object per record; mutually exclusive with the single-record flags)
+zinkee --json records create projects --records-file ./projects.json
+
 # List and query
 zinkee --json records list projects --limit 50
 zinkee --json records query projects --limit 10 --sort "_id:desc"
@@ -299,8 +302,11 @@ zinkee --json records get projects <record-uuid>
 # Update
 zinkee records update projects <record-uuid> --set status=2
 
-# Delete
-zinkee records delete projects <record-uuid>
+# Delete one or more records (--record is repeatable)
+zinkee records delete projects --record <record-uuid> --record <record-uuid>
+
+# Delete many records listing one uuid per line in a file (merged with --record, de-duplicated)
+zinkee records delete projects --records-file ./record-ids.txt
 
 # Clear all records from a schema (destructive — irreversible)
 zinkee records clear projects

package/dist/index.js

@@ -2832,35 +2832,55 @@ var specificExamples = {
   ]),
   "records create": buildCommandExamples([
     {
-      description: "Minimal create using just two plain string fields.",
+      description: "Create a single record with --set/--set-json (the single-record flags build one record, sent as a one-element 'records' array).",
       command: `zinkee --json records create contacts --set contact-name="Ada Lovelace" --set contact-email=ada@example.com`,
       raw: `{
-  "values": {
-    "contact-name": "Ada Lovelace",
-    "contact-email": "ada@example.com"
-  }
+  "records": [
+    {
+      "contact-name": "Ada Lovelace",
+      "contact-email": "ada@example.com"
+    }
+  ]
 }`,
       response: `{
-  "recordId": "550e8400-e29b-41d4-a716-446655440000",
-  "values": {
-    "contact-name": "Ada Lovelace",
-    "contact-email": "ada@example.com"
-  }
+  "created": [
+    "550e8400-e29b-41d4-a716-446655440000"
+  ],
+  "errors": []
 }`
     },
     {
-      description: "Create a record mixing text, option, number, date, reference and member fields. ReferenceField values must match the target's current targetDisplayField (read it from the target record before writing).",
-      command: `zinkee --json records create contacts --set contact-name="Grace Hopper" --set contact-email=grace@example.com --set status=2 --set amount=1999.99 --set due-date=2026-06-01T09:00:00Z --set customer-ref="CUST-12" --set owner=6c8a3e0d-4e5f-4a1b-9c2d-3e4f5a6b7c8d`,
+      description: "Create many records from a JSON array file (one object per record, slug -> value). Best-effort: valid records are created and invalid ones are reported per index in 'errors'. ReferenceField values must match the target's current targetDisplayField.",
+      command: `zinkee --json records create contacts --records-file ./records.json`,
       raw: `{
-  "values": {
-    "contact-name": "Grace Hopper",
-    "contact-email": "grace@example.com",
-    "status": 2,
-    "amount": 1999.99,
-    "due-date": "2026-06-01T09:00:00Z",
-    "customer-ref": "CUST-12",
-    "owner": "6c8a3e0d-4e5f-4a1b-9c2d-3e4f5a6b7c8d"
-  }
+  "records": [
+    {
+      "contact-name": "Ada Lovelace",
+      "contact-email": "ada@example.com"
+    },
+    {
+      "contact-name": "Grace Hopper",
+      "contact-email": "grace@example.com",
+      "status": 2,
+      "amount": 1999.99,
+      "due-date": "2026-06-01T09:00:00Z",
+      "customer-ref": "8ad602a1-f6e3-43f6-9ab2-f1c5afc99621",
+      "owner": "6c8a3e0d-4e5f-4a1b-9c2d-3e4f5a6b7c8d"
+    }
+  ]
+}`,
+      response: `{
+  "created": [
+    "550e8400-e29b-41d4-a716-446655440000"
+  ],
+  "errors": [
+    {
+      "index": 1,
+      "reason": "record_field_not_found",
+      "message": "Field 'contact-emial' was not found in schema '2eb8bdcf-6d9c-4fbb-9018-7fa8180f4c5e'.",
+      "action": "Use a valid field slug from the schema and retry."
+    }
+  ]
 }`
     }
   ]),
@@ -4533,10 +4553,24 @@ var specificExamples = {
   ]),
   "records delete": buildCommandExamples([
     {
-      description: "Delete a record.",
-      command: `zinkee --json records delete contacts ${SAMPLE_UUID}`,
+      description: "Delete one or more records by id (--record is repeatable).",
+      command: `zinkee --json records delete contacts --record 550e8400-e29b-41d4-a716-446655440000 --record 6c8a3e0d-4e5f-4a1b-9c2d-3e4f5a6b7c8d`,
       response: `{
-  "recordId": "550e8400-e29b-41d4-a716-446655440000",
+  "recordIds": [
+    "550e8400-e29b-41d4-a716-446655440000",
+    "6c8a3e0d-4e5f-4a1b-9c2d-3e4f5a6b7c8d"
+  ],
+  "deleted": true
+}`
+    },
+    {
+      description: "Delete many records listing one uuid per line in a file (merged with any --record flags and de-duplicated).",
+      command: `zinkee --json records delete contacts --records-file ./record-ids.txt`,
+      response: `{
+  "recordIds": [
+    "550e8400-e29b-41d4-a716-446655440000",
+    "6c8a3e0d-4e5f-4a1b-9c2d-3e4f5a6b7c8d"
+  ],
   "deleted": true
 }`
     }
@@ -10721,10 +10755,10 @@ var RecordsApi = class {
       `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`
     );
   }
-  createRecord(schema, input) {
+  createRecords(schema, records) {
     return this.client.requestJson(
       `/api/v2/schemas/${selectorValue8(schema)}/records`,
-      jsonOptions6(input, "POST")
+      jsonOptions6({ records }, "POST")
     );
   }
   updateRecord(schema, record, input) {
@@ -10733,10 +10767,10 @@ var RecordsApi = class {
       jsonOptions6(input, "PATCH")
     );
   }
-  deleteRecord(schema, record) {
+  deleteRecords(schema, recordIds) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`,
-      { method: "DELETE" }
+      `/api/v2/schemas/${selectorValue8(schema)}/records:delete`,
+      jsonOptions6({ recordIds }, "POST")
     );
   }
   clearRecords(schema) {
@@ -10960,6 +10994,61 @@ function parseJsonKeyValueAssignment(input) {
 function dedupeStrings(values) {
   return [...new Set(values)];
 }
+function toRecordUuid(value) {
+  try {
+    const normalized = normalizeUuidOrSlug(value);
+    return normalized.kind === "uuid" ? normalized.value : null;
+  } catch {
+    return null;
+  }
+}
+function collectRecordIds(value, previous = []) {
+  const uuid = toRecordUuid(value.trim());
+  if (!uuid) {
+    throw new InvalidArgumentError8(`Expected a record UUID, received "${value}".`);
+  }
+  return [...previous, uuid];
+}
+function readRecordIdsFromFile(path) {
+  let contents;
+  try {
+    contents = readFileSync8(path, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unable to read file.";
+    throw new CliError(
+      "invalid_cli_usage",
+      `Failed to read record ids from ${path}: ${message}`
+    );
+  }
+  const ids = [];
+  contents.split(/\r?\n/).forEach((line, index) => {
+    const value = line.trim();
+    if (!value) {
+      return;
+    }
+    const uuid = toRecordUuid(value);
+    if (!uuid) {
+      throw new CliError(
+        "invalid_cli_usage",
+        `Invalid record UUID "${value}" at ${path}:${index + 1}.`
+      );
+    }
+    ids.push(uuid);
+  });
+  return ids;
+}
+function resolveDeleteRecordIds(options) {
+  const flagIds = options.record ?? [];
+  const fileIds = options.recordsFile ? readRecordIdsFromFile(options.recordsFile) : [];
+  const recordIds = dedupeStrings([...flagIds, ...fileIds]);
+  if (recordIds.length === 0) {
+    throw new CliError(
+      "invalid_cli_usage",
+      'Provide at least one record id via "--record <uuid>" (repeatable) or "--records-file <path>".'
+    );
+  }
+  return recordIds;
+}
 function collectStringValues(value, previous = []) {
   return [...previous, value];
 }
@@ -11071,7 +11160,60 @@ function buildRecordQueryInput(options, allowRaw) {
   }
   return input;
 }
-function buildRecordCreateInput(options) {
+function readRecordsFromFile(path) {
+  let contents;
+  try {
+    contents = readFileSync8(path, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unable to read file.";
+    throw new CliError(
+      "invalid_cli_usage",
+      `Failed to read records from ${path}: ${message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON.";
+    throw new CliError(
+      "invalid_cli_usage",
+      `Failed to parse JSON from --records-file ${path}: ${message}`
+    );
+  }
+  if (!Array.isArray(parsed)) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Expected --records-file ${path} to contain a JSON array of record objects.`
+    );
+  }
+  if (parsed.length === 0) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `--records-file ${path} must contain at least one record.`
+    );
+  }
+  return parsed.map((record, index) => {
+    if (!isJsonObject6(record)) {
+      throw new CliError(
+        "invalid_cli_usage",
+        `Record at index ${index} in --records-file ${path} must be a JSON object.`
+      );
+    }
+    return record;
+  });
+}
+function buildCreateRecords(options) {
+  const hasSingleRecordFlags = (options.set?.length ?? 0) > 0 || (options.setJson?.length ?? 0) > 0 || options.raw !== void 0 || options.rawFile !== void 0;
+  if (options.recordsFile !== void 0) {
+    if (hasSingleRecordFlags) {
+      throw new CliError(
+        "invalid_cli_usage",
+        'Provide either "--records-file" or the single-record flags (--set/--set-json/--raw/--raw-file), not both.'
+      );
+    }
+    return readRecordsFromFile(options.recordsFile);
+  }
   const values = {
     ...readRawObject3(options.raw, options.rawFile),
     ...buildAssignmentObject(options.set, options.setJson)
@@ -11079,10 +11221,10 @@ function buildRecordCreateInput(options) {
   if (isEmptyObject5(values)) {
     throw new CliError(
       "invalid_cli_usage",
-      'Provide record fields via "--set", "--set-json", "--raw", or "--raw-file".'
+      'Provide record fields via "--set", "--set-json", "--raw", "--raw-file", or load multiple records with "--records-file".'
     );
   }
-  return { values };
+  return [values];
 }
 function buildRecordUpdateInput(options) {
   const raw = readRawObject3(options.raw, options.rawFile);
@@ -11205,19 +11347,26 @@ function registerRecordsCommands(program, options = {}) {
     }
     emitTable4(stdout, data);
   });
-  records.command("create").description("Create a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
+  records.command("create").description("Create one or more records").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").option(
+    "--records-file <path>",
+    "path to a JSON array of record objects (mutually exclusive with --set/--set-json/--raw/--raw-file)"
+  ).action(async function action(schema, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
     ensureWritable7("records create", readOnly, "write");
+    const records2 = buildCreateRecords(commandOptions);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
-    const data = await api.createRecord(
-      resolvedSchema,
-      buildRecordCreateInput(commandOptions)
-    );
+    const data = await api.createRecords(resolvedSchema, records2);
     if (json) {
       emitJson10(stdout, "records create", data, filePath);
       return;
     }
-    writeLine10(stdout, `Created record "${getRecordIdentifier(data)}".`);
+    writeLine10(stdout, `Created ${data.created.length} record(s) in schema "${schema.value}".`);
+    if (data.errors.length > 0) {
+      writeLine10(stdout, `${data.errors.length} record(s) rejected:`);
+      for (const error of data.errors) {
+        writeLine10(stdout, `  - index ${error.index}: ${error.message}`);
+      }
+    }
   });
   records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--unset <field>", "unset a field", collectStringValues, []).option("--raw <json>", "raw JSON object of fields to set").option("--raw-file <path>", "path to a JSON object of fields to set").action(async function action(schema, record, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
@@ -11234,21 +11383,23 @@ function registerRecordsCommands(program, options = {}) {
     }
     writeLine10(stdout, `Updated record "${getRecordIdentifier(data)}".`);
   });
-  records.command("delete").description("Delete a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, record) {
+  records.command("delete").description("Delete one or more records").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--record <uuid>", "record uuid to delete (repeatable)", collectRecordIds, []).option(
+    "--records-file <path>",
+    "path to a file with one record uuid per line (merged with --record)"
+  ).action(async function action(schema, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
     ensureWritable7("records delete", readOnly, "destructive");
+    const recordIds = resolveDeleteRecordIds(commandOptions);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
-    await api.deleteRecord(resolvedSchema, record);
-    const data = {
-      schema: resolvedSchema.value,
-      record: record.value,
-      deleted: true
-    };
+    const data = await api.deleteRecords(resolvedSchema, recordIds);
     if (json) {
       emitJson10(stdout, "records delete", data, filePath);
       return;
     }
-    writeLine10(stdout, `Deleted record "${record.value}" from schema "${schema.value}".`);
+    writeLine10(
+      stdout,
+      `Deleted ${recordIds.length} record(s) from schema "${schema.value}".`
+    );
   });
   records.command("clear").description("Delete all records from a schema's table").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);