lazypock 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -22,10 +22,18 @@ var index_exports = {};
 __export(index_exports, {
   ApiError: () => ApiError,
   AuthStore: () => AuthStore,
+  CollectionService: () => CollectionService,
   FilesService: () => FilesService,
   LazypockClient: () => LazypockClient,
   RealtimeService: () => RealtimeService,
+  TypedClient: () => TypedClient,
+  collectionTypeName: () => collectionTypeName,
+  createClient: () => createClient,
+  fieldTypeKind: () => fieldTypeKind,
+  fieldTypeScriptType: () => fieldTypeScriptType,
+  generateTypes: () => generateTypes,
   getFileUrl: () => getFileUrl,
+  schemaFieldType: () => schemaFieldType,
   wsUrlFromBaseUrl: () => wsUrlFromBaseUrl
 });
 module.exports = __toCommonJS(index_exports);
@@ -321,12 +329,25 @@ var memoryStorage = {
 };
 
 // src/collection.ts
+function normalizeAction(event, rawAction) {
+  if (typeof rawAction === "string") {
+    const a = rawAction.toLowerCase();
+    if (a === "create" || a === "update" || a === "delete") {
+      return a;
+    }
+  }
+  if (event === "record_change") return "update";
+  if (event === "create" || event === "record_create") return "create";
+  if (event === "delete" || event === "record_delete") return "delete";
+  return "update";
+}
 var CollectionService = class {
   /** @internal */
-  constructor(http, collectionName, authStore) {
+  constructor(http, collectionName, authStore, realtime) {
     this.http = http;
     this.collectionName = collectionName;
     this.authStore = authStore;
+    this.realtime = realtime;
   }
   encodeId(id) {
     return encodeURIComponent(id);
@@ -356,7 +377,8 @@ var CollectionService = class {
   }
   /**
    * Create a new record.
-   * @param data Record fields.
+   * @param data Record fields. When `T` is a concrete shape (e.g. a generated
+   * record type), excess/unknown fields are rejected at compile time.
    * @param options Optional request options.
    */
   create(data, options) {
@@ -369,7 +391,8 @@ var CollectionService = class {
   /**
    * Update a record by ID.
    * @param id Record ID.
-   * @param data Updated record fields.
+   * @param data Updated record fields. When `T` is a concrete shape, `data`
+   * must be a partial of `T` — unknown fields are rejected.
    * @param options Optional request options.
    */
   update(id, data, options) {
@@ -396,16 +419,73 @@ var CollectionService = class {
    * Useful for constructing `expand` query parameters.
    */
   async expandFields(options) {
-    const data = await this.http.get(
-      "/collections/" + this.encodeId(this.collectionName),
-      options
-    );
+    const data = await this.http.get("/collections/" + this.encodeId(this.collectionName), options);
     if (!data?.fields) return null;
     return data.fields.filter((f) => f.type === "relation" && f.options?.collection).map((f) => ({
       field: f.name,
       targetCollection: f.options.collection
     }));
   }
+  /**
+   * Cast this service to a specific record shape.
+   * Use when you have a hand-written or generated interface for the
+   * collection and want compile-time checking of create/update/list.
+   *
+   * @example
+   * ```ts
+   * interface Post {
+   *   id: string;
+   *   title: string;
+   *   published: boolean;
+   * }
+   * const posts = client.collection("posts").typed<Post>();
+   * await posts.create({ title: "Hi", published: true }); // ✓
+   * await posts.create({ nope: 1 }); // ✗ compile error
+   * ```
+   */
+  typed() {
+    return this;
+  }
+  // ── Realtime Subscriptions (PocketBase-style) ──
+  /**
+   * Subscribe to realtime changes for this collection.
+   * The event's `action` is one of `"create" | "update" | "delete"`.
+   *
+   * Access is governed by the collection's `listRule` (PocketBase semantics):
+   * public collections allow anonymous subscriptions; other collections
+   * require a matching logged-in user or superuser.
+   *
+   * @param callback Received on every record change.
+   * @param recordId Optional — subscribe to a single record instead of `*`.
+   * @returns A function that unsubscribes this callback.
+   */
+  subscribe(callback, recordId) {
+    if (!this.realtime) {
+      console.warn("[lazypock] No realtime service configured.");
+      return () => {
+      };
+    }
+    const topic = "collection:" + this.collectionName + (recordId ? ":" + recordId : "");
+    const handler = (raw) => {
+      const record = raw.payload?.["record"] ?? {};
+      callback({
+        action: normalizeAction(raw.event, raw.payload?.["action"]),
+        record,
+        topic: raw.topic
+      });
+    };
+    this.realtime.ensureConnected();
+    this.realtime.subscribe(topic, handler);
+    return () => this.realtime?.unsubscribe(topic, handler);
+  }
+  /**
+   * Unsubscribe all callbacks from this collection (or a specific record).
+   * @param recordId Optional record id; omitting it unsubs everything.
+   */
+  unsubscribe(recordId) {
+    const topic = "collection:" + this.collectionName + (recordId ? ":" + recordId : "");
+    this.realtime?.unsubscribe(topic);
+  }
   // ── Auth Collection Methods ──
   /**
    * Authenticate with email/password against this auth collection.
@@ -442,6 +522,7 @@ var CollectionService = class {
   /**
    * Get available auth methods for this collection.
    */
+  // ── end Realtime ──
   async authMethods(options) {
     return this.http.get(
       "/" + this.encodeId(this.collectionName) + "/auth-methods",
@@ -472,6 +553,39 @@ var RealtimeService = class {
     // ── Heartbeat ──
     this.heartbeatInterval = null;
   }
+  /** Whether the WebSocket is currently open. */
+  get isOpen() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * The most recently used WebSocket URL (set on {@link connect}).
+   * Useful for SDK convenience methods that auto-connect before subscribing.
+   */
+  get lastUrl() {
+    return this.url;
+  }
+  /** The auth token configured for this connection (set on connect). */
+  get lastToken() {
+    return this.token;
+  }
+  /**
+   * Set the socket URL. Useful before subscribing so the SDK can
+   * auto-connect on the first {@link subscribe}.
+   */
+  setUrl(url) {
+    this.url = url;
+  }
+  /*
+   * Ensure the socket is connected, then subscribe.
+   * Used by collection-level convenience wrappers so a connection is opened
+   * automatically on the first subscribe (matching PocketBase behaviour —
+   * works for anonymous/public collections too).
+   */
+  ensureConnected() {
+    if (this.isOpen || !this.url) return;
+    if (typeof WebSocket === "undefined") return;
+    this.doConnect();
+  }
   connect(opts) {
     this.url = opts.url;
     this.token = opts.token;
@@ -694,7 +808,189 @@ var FilesService = class {
   }
 };
 
-// src/index.ts
+// src/typegen.ts
+function fieldTypeScriptType(field, fallback = "unknown") {
+  const opts = field.options ?? {};
+  switch (field.type) {
+    case "text":
+    case "email":
+    case "url":
+    case "editor":
+    case "date":
+    case "datetime":
+      return "string";
+    case "number":
+      return "number";
+    case "bool":
+      return "boolean";
+    case "select": {
+      const values = Array.isArray(opts.values) ? opts.values : [];
+      if (values.length > 0) {
+        return values.map((v) => JSON.stringify(String(v))).join(" | ");
+      }
+      return "string";
+    }
+    case "multi_select": {
+      const values = Array.isArray(opts.values) ? opts.values : [];
+      if (values.length > 0) {
+        return `(${values.map((v) => JSON.stringify(String(v))).join(" | ")})[]`;
+      }
+      return "string[]";
+    }
+    case "file":
+      return "string";
+    case "multi_file":
+      return "string[]";
+    case "json":
+    case "geo":
+      return "Record<string, unknown>";
+    case "relation":
+      return (opts.maxSelect ?? 1) > 1 ? "string[]" : "string";
+    case "password":
+      return "never";
+    default:
+      return fallback;
+  }
+}
+function fieldTypeKind(field) {
+  const opts = field.options ?? {};
+  switch (field.type) {
+    case "text":
+    case "email":
+    case "url":
+    case "editor":
+    case "date":
+    case "datetime":
+    case "select":
+    case "file":
+      return "string";
+    case "number":
+      return "number";
+    case "bool":
+      return "boolean";
+    case "multi_select":
+    case "multi_file":
+      return "string-array";
+    case "json":
+    case "geo":
+      return "json";
+    case "relation":
+      return (opts.maxSelect ?? 1) > 1 ? "relation-many" : "relation";
+    case "password":
+      return "password";
+    default:
+      return "unknown";
+  }
+}
+function schemaFieldType(field) {
+  switch (fieldTypeKind(field)) {
+    case "string":
+      return String;
+    case "number":
+      return Number;
+    case "boolean":
+      return Boolean;
+    case "string-array":
+      return [String];
+    case "relation":
+      return String;
+    case "relation-many":
+      return [String];
+    case "json":
+      return Object;
+    case "password":
+      return void 0;
+    case "unknown":
+      return void 0;
+  }
+}
+
+// src/codegen.ts
+function collectionTypeName(name) {
+  return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("").replace(/^[0-9]/, "_$&");
+}
+function fieldKey(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function generateTypes(collections, options = {}) {
+  const {
+    packageName = "lazypock",
+    includeBaseFields = true,
+    skipSystem = false
+  } = options;
+  const filtered = skipSystem ? collections.filter(
+    (c) => !c.system && !c.name.startsWith("_") && c.name !== "users"
+  ) : collections;
+  const sections = [];
+  sections.push(`// \u2500\u2500 Auto-generated by lazypock-ts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+// Do not edit by hand. Regenerate with: npx lazypock-gen
+// Schema snapshot: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  if (includeBaseFields) {
+    sections.push(`export interface BaseRecord {
+  id: string;
+  collectionId: string;
+  collectionName: string;
+  created: string;
+  updated: string;
+}`);
+  }
+  for (const coll of filtered) {
+    const typeName = collectionTypeName(coll.name);
+    const fields = coll.fields ?? [];
+    const lines = fields.map((f) => memberLine(f)).filter((l) => l !== "");
+    const body = lines.join("\n");
+    sections.push(
+      `export interface ${typeName}Record${renderInterface({
+        extends: includeBaseFields ? "BaseRecord" : void 0,
+        body
+      })}`
+    );
+  }
+  sections.push(`export interface AuthRecord extends BaseRecord {
+  email: string;
+  verified: boolean;
+}`);
+  const mapEntries = filtered.map(
+    (c) => `  "${c.name}": ${collectionTypeName(c.name)}Record${c.type === "auth" ? " & AuthRecord" : ""};`
+  ).join("\n");
+  sections.push(`export interface LazypockCollections {
+${mapEntries}
+}`);
+  sections.push(`import { LazypockClient, type LazypockClientOptions, type CollectionService } from "${packageName}";
+
+/**
+ * Create a Lazypock client typed against this schema snapshot.
+ * Collection access is fully type-checked:
+ *   client.collection("posts").create({ title: "x" }) // title must exist
+ */
+export function createClient(options: LazypockClientOptions): TypedClient {
+  return new TypedClient(options);
+}
+
+export class TypedClient extends LazypockClient {
+  override collection<K extends keyof LazypockCollections>(name: K): CollectionService<LazypockCollections[K]>;
+  override collection(name: string): CollectionService<unknown> {
+    return super.collection(name) as unknown as CollectionService<unknown>;
+  }
+}`);
+  return sections.join("\n\n") + "\n";
+}
+function renderInterface(opts) {
+  const ext = opts.extends ? ` extends ${opts.extends}` : "";
+  if (!opts.body) return `${ext} {}`;
+  return `${ext} {
+${opts.body}
+}`;
+}
+function memberLine(f) {
+  const key = fieldKey(f.name);
+  const req = f.required || f.type === "password" ? "" : "?";
+  const type = fieldTypeScriptType(f);
+  if (type === "never") return "";
+  return `  ${JSON.stringify(key)}${req}: ${type};`;
+}
+
+// src/lazypock.ts
 var LazypockClient = class {
   /**
    * Create a new Lazypock client.
@@ -706,23 +1002,59 @@ var LazypockClient = class {
     this.authStore = options.authStore ?? new AuthStore(options.storage ?? memoryStorage);
     this.http = new HttpClient(baseUrl, this.authStore);
     this.realtime = options.realtime ?? new RealtimeService();
+    if (!options.realtime) {
+      this.realtime.setUrl(wsUrlFromBaseUrl(baseUrl));
+    }
     this.files = new FilesService(this.http);
+    if (options.types?.schemas) {
+      this.schemaByName = new Map(
+        options.types.schemas.map((s) => [s.name, s])
+      );
+    }
   }
   /**
-   * Get or create a typed service for the given collection.
+   * Get or create a service for the given collection.
    * Services are cached after first access.
    *
+   * For typed CRUD, either:
+   *   - cast at the call site: `client.collection("posts").typed<Post>()`
+   *   - or use the typed factory: `createClient<{ posts: Post }>()`
+   *
    * @param name The collection name.
    * @returns A {@link CollectionService} instance.
    */
   collection(name) {
     let svc = this.collectionCache.get(name);
     if (!svc) {
-      svc = new CollectionService(this.http, name, this.authStore);
+      svc = new CollectionService(
+        this.http,
+        name,
+        this.authStore,
+        this.realtime
+      );
       this.collectionCache.set(name, svc);
     }
     return svc;
   }
+  /**
+   * Get a typed service whose record shape is derived from the schema
+   * passed via `options.types.schemas` (if available), or fall back to
+   * the untyped service otherwise.
+   *
+   * @experimental
+   */
+  collectionFor(name) {
+    return this.collection(name);
+  }
+  /**
+   * Generate TypeScript types from the schemas provided to this client
+   * (via `options.types.schemas`). Returns a string ready to write to a
+   * `lazypock.types.ts` file.
+   */
+  generateTypes(options) {
+    const schemas = this.schemaByName ? [...this.schemaByName.values()] : [];
+    return generateTypes(schemas, options);
+  }
   // ── Auth ──
   /** Check whether any superuser exists (for login vs setup screen routing). */
   async checkSuperuser() {
@@ -958,14 +1290,32 @@ var LazypockClient = class {
     );
   }
 };
+
+// src/client.ts
+var TypedClient = class extends LazypockClient {
+  collection(name) {
+    return super.collection(name);
+  }
+};
+function createClient(options) {
+  return new TypedClient(options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiError,
   AuthStore,
+  CollectionService,
   FilesService,
   LazypockClient,
   RealtimeService,
+  TypedClient,
+  collectionTypeName,
+  createClient,
+  fieldTypeKind,
+  fieldTypeScriptType,
+  generateTypes,
   getFileUrl,
+  schemaFieldType,
   wsUrlFromBaseUrl
 });
 //# sourceMappingURL=index.cjs.map