lazypock 0.7.0 → 0.8.1

package/dist/index.cjs

@@ -519,9 +519,10 @@ var CollectionService = class _CollectionService {
    * const t = await client.collection("posts").select("id", "title").getList();
    * // GET /api/posts?fields=id,title
    *
-   * // All visible fields (hidden fields are excluded server-side)
+   * // All visible fields (implicit system keys id/created/updated/… are
+   * // kept; hidden fields are excluded via the projection)
    * const all = await client.collection("posts").select("*").getList();
-   * // GET /api/posts?fields=id,title,published,… (schema known)
+   * // GET /api/posts?fields=id,created,updated,collectionId,collectionName,title,published,… (schema known)
    * ```
    *
    * When no schema is known, the default (no `select()` call) sends no
@@ -554,7 +555,8 @@ var CollectionService = class _CollectionService {
    * Fields to send with reads:
    * 1. explicit `options.fields` (caller wins)
    * 2. `select()` preset
-   * 3. schema default — all visible (non-hidden, non-system) fields
+   * 3. schema default — all visible (non-hidden) fields plus the implicit
+   *    system keys (`id`, `created`, `updated`, `collectionId`, `collectionName`)
    */
   effectiveFields(optionsFields) {
     if (optionsFields !== void 0) return optionsFields;
@@ -567,15 +569,35 @@ var CollectionService = class _CollectionService {
     return this.visibleFields();
   }
   /**
-   * All non-hidden, non-system, non-password field names from the schema.
-   * `undefined` when no schema is available (server decides).
+   * All non-hidden, non-password, non-autodate field names from the schema,
+   * prefixed with the implicit system keys that are part of every record
+   * (`id`, `created`, `updated`, `collectionId`, `collectionName`).
+   *
+   * The system keys never appear in the schema (they are implied for every
+   * collection) but MUST be listed explicitly when projecting — the server
+   * applies strict projection, so unrequested fields are dropped. Without
+   * them, `getList`/`getOne` responses lose `id` (and `created`/`updated`),
+   * breaking selection, edits, and relation references.
+   *
+   * `undefined` when no schema fields are available (server decides — its
+   * default returns every non-password field, including the system keys).
    */
   visibleFields() {
     if (!this.schema?.fields) return void 0;
     const visible = this.schema.fields.filter(
       (f) => !f.hidden && f.type !== "password" && f.type !== "autodate"
     ).map((f) => f.name);
-    return visible.length > 0 ? visible.join(",") : void 0;
+    if (visible.length === 0) return void 0;
+    return [
+      .../* @__PURE__ */ new Set([
+        "id",
+        "created",
+        "updated",
+        "collectionId",
+        "collectionName",
+        ...visible
+      ])
+    ].join(",");
   }
   /** Warn once when an expand field is not a relation (schema known). */
   validateExpand(expand) {
@@ -1461,6 +1483,12 @@ function generateTypes(collections, options = {}) {
         body
       })}`
     );
+    const createLines = fields.map((f) => createDataMemberLine(f)).filter((l) => l !== "");
+    sections.push(
+      `export interface ${typeName}CreateData${renderInterface({
+        body: createLines.join("\n")
+      })}`
+    );
   }
   sections.push(`export interface AuthRecord extends BaseRecord {
   email: string;
@@ -1471,6 +1499,10 @@ function generateTypes(collections, options = {}) {
   ).join("\n");
   sections.push(`export interface LazypockCollections {
 ${mapEntries}
+}`);
+  const createMapEntries = filtered.map((c) => `  "${c.name}": ${collectionTypeName(c.name)}CreateData;`).join("\n");
+  sections.push(`export interface LazypockCreateData {
+${createMapEntries}
 }`);
   const schemaEntries = collections.map(
     (c) => `  {
@@ -1494,6 +1526,10 @@ ${schemaEntries}
  * Collection access is fully type-checked:
  *   client.collection("posts").create({ title: "x" }) // title must exist
  *
+ * For auth collections the generated *CreateData type includes the
+ * write-only password field, so creating a user is type-safe:
+ *   client.collection("users").create({ email, password }) // \u2713
+ *
  * The schema snapshot is wired into the client automatically, so hidden
  * fields are excluded from responses and select/expand are validated.
  */
@@ -1508,10 +1544,16 @@ export function createClient(options: LazypockClientOptions): TypedClient {
 }
 
 export class TypedClient extends LazypockClient {
-  override collection<T extends string>(name: T): T extends keyof LazypockCollections
-    ? CollectionService<LazypockCollections[T]>
-    : CollectionService<unknown> {
-    return super.collection(name) as T extends keyof LazypockCollections ? CollectionService<LazypockCollections[T]> : CollectionService<unknown>;
+  // K extends keyof LazypockCollections (rather than a generic string with a
+  // conditional return) so the IDE suggests collection names and unknown names
+  // are rejected at compile time:
+  //   client.collection("posts")  // suggested + typed
+  //   client.collection("nope")   // TS error
+  //
+  // create()/update() take the collection's *CreateData \u2014 the read model
+  // omits password/hidden fields, but the write model carries them.
+  override collection<K extends keyof LazypockCollections>(name: K): CollectionService<LazypockCollections[K], LazypockCreateData[K]> {
+    return super.collection(name) as CollectionService<LazypockCollections[K], LazypockCreateData[K]>;
   }
 }
 `);
@@ -1532,6 +1574,14 @@ function memberLine(f) {
   if (type === "never") return "";
   return `  ${JSON.stringify(key)}${req}: ${type};`;
 }
+function createDataMemberLine(f) {
+  if (f.type === "autodate") return "";
+  const key = fieldKey(f.name);
+  const req = f.required ? "" : "?";
+  const type = f.type === "password" ? "string" : fieldTypeScriptType(f);
+  if (type === "never") return "";
+  return `  ${JSON.stringify(key)}${req}: ${type};`;
+}
 
 // src/lazypock.ts
 var LazypockClient = class {
@@ -1543,6 +1593,7 @@ var LazypockClient = class {
     this.collectionCache = /* @__PURE__ */ new Map();
     const baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.authStore = options.authStore ?? new AuthStore(options.storage ?? memoryStorage);
+    this.authReady = options.authStore ? Promise.resolve() : this.authStore.init();
     this.http = new HttpClient(baseUrl, this.authStore);
     this.realtime = options.realtime ?? new RealtimeService();
     if (!options.realtime) {