@juanito_boop/w-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,663 @@
+// src/http/auth.ts
+function buildQueryString(params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value) query.append(key, value);
+  });
+  const str = query.toString();
+  return str ? `?${str}` : "";
+}
+function createAuthHttp(opts) {
+  const fetcher = opts.fetch ?? globalThis.fetch;
+  async function post(path, body) {
+    try {
+      const res = await fetcher(`${opts.baseUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.apiKey ? { "x-api-key": opts.apiKey } : {}
+        },
+        body: JSON.stringify(body)
+      });
+      const json = await res.json().catch(() => null);
+      if (!res.ok) {
+        return {
+          success: false,
+          error: {
+            message: json?.message ?? res.statusText,
+            code: json?.code,
+            statusCode: res.status,
+            details: json
+          }
+        };
+      }
+      return { success: true, data: json };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          message: err instanceof Error ? err.message : "Network error",
+          code: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  async function get(path) {
+    try {
+      const res = await fetcher(`${opts.baseUrl}${path}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.apiKey ? { "x-api-key": opts.apiKey } : {}
+        }
+      });
+      const json = await res.json().catch(() => null);
+      if (!res.ok) {
+        return {
+          success: false,
+          error: {
+            message: json?.message ?? res.statusText,
+            code: json?.code,
+            statusCode: res.status,
+            details: json
+          }
+        };
+      }
+      return { success: true, data: json };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          message: err instanceof Error ? err.message : "Network error",
+          code: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  async function del(path) {
+    try {
+      const res = await fetcher(`${opts.baseUrl}${path}`, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.apiKey ? { "x-api-key": opts.apiKey } : {}
+        }
+      });
+      const json = await res.json().catch(() => null);
+      if (!res.ok) {
+        return {
+          success: false,
+          error: {
+            message: json?.message ?? res.statusText,
+            code: json?.code,
+            statusCode: res.status,
+            details: json
+          }
+        };
+      }
+      return { success: true, data: json };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          message: err instanceof Error ? err.message : "Network error",
+          code: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  return {
+    register: (data) => post("/auth/register", data),
+    login: (data) => post("/auth/login", data),
+    logout: (data) => post("/auth/logout", data),
+    requestMagicLink: (data) => post("/auth/magic-link/request", data),
+    verifyMagicLink: (token) => post("/auth/magic-link/verify", { token }),
+    createApiKey: (data) => post("/auth/api-keys", data),
+    listApiKeys: (userId) => get(`/auth/api-keys/${userId}`),
+    revokeApiKey: (userId, keyId) => del(`/auth/api-keys/${userId}/${keyId}`),
+    validateSession: (token) => post("/auth/validate-session", { token }),
+    rollbackApiKey: (data) => {
+      const query = buildQueryString({
+        fromActivityId: data.fromActivityId,
+        fromTimestamp: data.fromTimestamp,
+        initiatedBy: data.initiatedBy
+      });
+      return post(
+        `/auth/api-keys/${data.keyId}/rollback${query}`,
+        {}
+      );
+    },
+    verifyMagicLinkWithQuery: (token) => get(`/auth/magic-link/verify?token=${token}`),
+    getSessions: (userId) => get(`/auth/sessions/${userId}`),
+    getLogs: () => get("/auth/logs"),
+    getUserLogs: (userId) => get(`/auth/logs/${userId}`),
+    getRollbackHistory: (keyId, limit = 50) => get(
+      `/auth/rollback-history${buildQueryString({ keyId, limit: String(limit) })}`
+    )
+  };
+}
+
+// src/ws/realtime.ts
+import { io } from "socket.io-client";
+async function toBytes(input) {
+  if (input instanceof Uint8Array) {
+    return Array.from(input);
+  }
+  if (input instanceof ArrayBuffer) {
+    return Array.from(new Uint8Array(input));
+  }
+  const arrayBuffer = await input.arrayBuffer();
+  return Array.from(new Uint8Array(arrayBuffer));
+}
+async function createWsImageFile(file, opts) {
+  if (file instanceof Blob) {
+    const detectedMime = opts?.mime ?? file.type;
+    const payload2 = {
+      filename: opts?.filename ?? file.name ?? "image.bin",
+      mime: detectedMime || "application/octet-stream",
+      buffer: await toBytes(file),
+      name: opts?.name,
+      expiration: opts?.expiration
+    };
+    return payload2;
+  }
+  const payload = {
+    filename: opts?.filename ?? "image.bin",
+    mime: opts?.mime ?? "application/octet-stream",
+    buffer: await toBytes(file),
+    name: opts?.name,
+    expiration: opts?.expiration
+  };
+  return payload;
+}
+function createRealtime(opts) {
+  let socket = null;
+  let apiKey = opts.apiKey;
+  const ACK_TIMEOUT_MS = 3e4;
+  function connect() {
+    return new Promise((resolve, reject) => {
+      if (socket?.connected) {
+        resolve();
+        return;
+      }
+      const auth = apiKey ? { apiKey } : void 0;
+      const extraHeaders = apiKey ? { "x-api-key": apiKey } : void 0;
+      let timeoutId;
+      socket = io(opts.baseUrl, {
+        path: "/ws",
+        transports: ["websocket", "polling"],
+        auth,
+        extraHeaders
+      });
+      const handleConnect = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        socket?.off("connect", handleConnect);
+        socket?.off("connect_error", handleError);
+        resolve();
+      };
+      const handleError = (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        socket?.off("connect", handleConnect);
+        socket?.off("connect_error", handleError);
+        reject(error);
+      };
+      socket.on("connect", handleConnect);
+      socket.on("connect_error", handleError);
+      timeoutId = setTimeout(() => {
+        socket?.off("connect", handleConnect);
+        socket?.off("connect_error", handleError);
+        reject(new Error("Connection timeout"));
+      }, 5e3);
+    });
+  }
+  function disconnect() {
+    socket?.disconnect();
+    socket = null;
+  }
+  function setApiKey(key) {
+    apiKey = key;
+    if (socket) {
+      disconnect();
+      connect();
+    }
+  }
+  function emitAck(event, payload) {
+    if (!socket) {
+      return Promise.resolve({
+        success: false,
+        error: {
+          message: "Socket no conectado",
+          code: "SOCKET_NOT_CONNECTED"
+        }
+      });
+    }
+    return new Promise((resolve) => {
+      socket.timeout(ACK_TIMEOUT_MS).emit(event, payload, (err, res) => {
+        if (err) {
+          resolve({
+            success: false,
+            error: {
+              message: err.message ?? "Socket error",
+              code: err.code ?? "SOCKET_ERROR",
+              details: err
+            }
+          });
+          return;
+        }
+        if (res?.error) {
+          resolve({
+            success: false,
+            error: {
+              message: res.error.message,
+              code: res.error.code,
+              details: res.error
+            }
+          });
+          return;
+        }
+        resolve({ success: true, data: res });
+      });
+    });
+  }
+  return {
+    connect,
+    disconnect,
+    setApiKey,
+    getWines: () => emitAck("get_wines", void 0),
+    getWinesPage: (page = 1, perPage = 16) => emitAck("get_wines_page", { page, perPage }),
+    insertWine: (data) => emitAck("insert_wine", data),
+    insertBulkWines: (data) => emitAck("insert_bulk_wines", data),
+    editWine: (data) => emitAck("edit_wine", data)
+  };
+}
+
+// src/client.ts
+var WineClient = class {
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error("baseUrl es requerido");
+    }
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.auth = createAuthHttp({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey
+    });
+    this.realtime = createRealtime({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey
+    });
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+    this.realtime.setApiKey(apiKey);
+  }
+  async connectRealtime() {
+    await this.realtime.connect();
+    return this.realtime;
+  }
+  disconnectRealtime() {
+    this.realtime.disconnect();
+  }
+};
+function createClient(options) {
+  return new WineClient(options);
+}
+
+// src/types.ts
+import { z } from "zod";
+
+// src/types/_helpers.ts
+function defineSchema(schema) {
+  return {
+    schema
+  };
+}
+
+// src/types.ts
+var ClientOptionsDef = defineSchema(
+  z.object({
+    baseUrl: z.url("baseUrl debe ser una URL v\xE1lida"),
+    apiKey: z.string().optional()
+  })
+);
+var ApiErrorDef = defineSchema(
+  z.object({
+    message: z.string(),
+    code: z.string().optional(),
+    statusCode: z.number().optional(),
+    details: z.unknown().optional()
+  })
+);
+var LoginDataDef = defineSchema(
+  z.object({
+    email: z.email("Email inv\xE1lido"),
+    password: z.string().min(1, "Password es requerido")
+  })
+);
+var RegisterDataDef = defineSchema(
+  z.object({
+    email: z.email("Email inv\xE1lido"),
+    password: z.string().min(6, "Password debe tener al menos 6 caracteres"),
+    fullName: z.string().optional()
+  })
+);
+var LogoutDataDef = defineSchema(
+  z.object({
+    token: z.string(),
+    logoutAll: z.boolean().optional()
+  })
+);
+var MagicLinkRequestDataDef = defineSchema(
+  z.object({
+    email: z.email("Email inv\xE1lido"),
+    redirectUrl: z.url().optional()
+  })
+);
+var AuthResponseDef = defineSchema(
+  z.object({
+    token: z.string(),
+    user: z.object({
+      id: z.uuid(),
+      email: z.email(),
+      fullName: z.string().optional()
+    }),
+    apiKey: z.object({
+      id: z.uuid(),
+      key: z.string(),
+      name: z.string(),
+      expiresAt: z.iso.datetime()
+    }).optional()
+  })
+);
+var ApiKeyDef = defineSchema(
+  z.object({
+    id: z.uuid(),
+    key: z.string(),
+    name: z.string(),
+    expiresAt: z.iso.datetime().optional(),
+    createdAt: z.iso.datetime()
+  })
+);
+var MagicLinkResponseDef = defineSchema(
+  z.object({
+    success: z.boolean(),
+    message: z.string(),
+    email: z.email()
+  })
+);
+var CreateApiKeyDef = z.object({
+  userId: z.uuid(),
+  name: z.string(),
+  expiresAt: z.iso.datetime().optional(),
+  // ISO 8601
+  expiresIn: z.number().positive().optional()
+  // Segundos
+});
+var RollbackApiKeyDataDef = z.object({
+  keyId: z.uuid(),
+  fromActivityId: z.uuid().optional(),
+  fromTimestamp: z.iso.datetime().optional(),
+  initiatedBy: z.string().optional()
+});
+var RollbackResponseDef = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  changesReverted: z.number(),
+  errors: z.array(z.string()),
+  rollbackSince: z.iso.datetime().optional()
+});
+var SessionDataDef = defineSchema(
+  z.object({
+    id: z.uuid(),
+    userId: z.uuid(),
+    token: z.string(),
+    ipAddress: z.string().nullable(),
+    userAgent: z.string().nullable(),
+    isActive: z.boolean(),
+    lastActivityAt: z.iso.datetime(),
+    createdAt: z.iso.datetime(),
+    expiresAt: z.iso.datetime().nullable()
+  })
+);
+var ValidateSessionResponseDef = defineSchema(
+  z.object({
+    valid: z.boolean(),
+    userId: z.uuid().optional(),
+    sessionId: z.uuid().optional()
+  })
+);
+var ActivityLogDef = defineSchema(
+  z.object({
+    id: z.uuid(),
+    userId: z.uuid().nullable().optional(),
+    apiKeyId: z.uuid().nullable().optional(),
+    action: z.string(),
+    ipAddress: z.string().nullable(),
+    userAgent: z.string().nullable(),
+    location: z.string().nullable(),
+    metadata: z.string().nullable(),
+    beforeState: z.string().nullable(),
+    afterState: z.string().nullable(),
+    tableName: z.string().nullable(),
+    recordId: z.uuid().nullable(),
+    timestamp: z.iso.datetime()
+  })
+);
+var RollbackLogDef = defineSchema(
+  z.object({
+    id: z.uuid(),
+    apiKeyId: z.uuid(),
+    initiatedBy: z.uuid().nullable().optional(),
+    status: z.string(),
+    changesReverted: z.string(),
+    errorMessage: z.string().nullable(),
+    createdAt: z.iso.datetime(),
+    completedAt: z.iso.datetime().nullable().optional()
+  })
+);
+var RealtimeOptionsDef = defineSchema(
+  z.object({
+    baseUrl: z.url(),
+    apiKey: z.string().optional()
+  })
+);
+var WineDataDef = defineSchema(
+  z.object({
+    id: z.uuid().optional()
+  }).strict()
+);
+var WineDetailsDef = defineSchema(
+  z.object({
+    id_detalle: z.uuid().nullable().optional(),
+    id_vino: z.uuid().nullable().optional(),
+    notas_cata: z.string().nullable().optional(),
+    tipo_crianza: z.string().nullable().optional(),
+    bodega: z.string().nullable().optional()
+  })
+);
+var WineDef = defineSchema(
+  z.object({
+    id_vino: z.uuid(),
+    nombre: z.string(),
+    precio: z.number(),
+    url_imagen: z.string(),
+    imgbb_delete_url: z.string().optional(),
+    image_hash: z.string().optional(),
+    descripcion: z.string(),
+    nivel_alcohol: z.number(),
+    variedades: z.array(z.string()),
+    pais_importacion: z.string(),
+    color_vino: z.string(),
+    stock: z.number(),
+    capacidad: z.number(),
+    wine_details: WineDetailsDef.schema.nullable().optional()
+  })
+);
+var EditWineDef = defineSchema(
+  WineDef.schema.omit({ wine_details: true }).partial().extend({
+    id_vino: z.uuid(),
+    wine_details: WineDetailsDef.schema.partial().optional(),
+    image_file: z.object({
+      filename: z.string().min(1),
+      mime: z.string().min(1),
+      buffer: z.union([
+        z.instanceof(Uint8Array),
+        z.array(z.number().int().min(0).max(255)),
+        z.object({
+          type: z.literal("Buffer"),
+          data: z.array(z.number().int().min(0).max(255))
+        })
+      ]),
+      name: z.string().optional(),
+      expiration: z.number().int().nonnegative().optional()
+    }).optional()
+  }).strict()
+);
+var CreateWineDef = defineSchema(
+  z.object({
+    nombre: z.string().min(1, 'El campo "nombre" es obligatorio'),
+    precio: z.number().positive("El precio debe ser positivo"),
+    url_imagen: z.string().optional(),
+    imgbb_delete_url: z.string().optional(),
+    image_hash: z.string().optional(),
+    descripcion: z.string().optional(),
+    nivel_alcohol: z.number().default(0),
+    variedades: z.array(z.string()).optional(),
+    pais_importacion: z.string().optional(),
+    color_vino: z.string().optional(),
+    stock: z.number().default(0),
+    capacidad: z.number().default(750),
+    notas_cata: z.string().optional(),
+    tipo_crianza: z.string().optional(),
+    bodega: z.string().optional(),
+    image_file: z.object({
+      filename: z.string().min(1),
+      mime: z.string().min(1),
+      buffer: z.union([
+        z.instanceof(Uint8Array),
+        z.array(z.number().int().min(0).max(255)),
+        z.object({
+          type: z.literal("Buffer"),
+          data: z.array(z.number().int().min(0).max(255))
+        })
+      ]),
+      name: z.string().optional(),
+      expiration: z.number().int().nonnegative().optional()
+    }).optional()
+  })
+);
+var BulkInsertWinesDef = defineSchema(z.array(CreateWineDef.schema));
+var BulkInsertWinesResultDef = defineSchema(
+  z.object({
+    total: z.number(),
+    successful: z.number(),
+    failed: z.number(),
+    results: z.array(
+      z.object({
+        insertado_id: z.string().nullable(),
+        error: z.string().nullable()
+      })
+    )
+  })
+);
+var ReusedWineImageDef = defineSchema(
+  z.object({
+    url: z.string(),
+    delete_url: z.string()
+  })
+);
+var ImgbbAssetDef = defineSchema(
+  z.object({
+    filename: z.string(),
+    name: z.string(),
+    mime: z.string(),
+    extension: z.string(),
+    url: z.string()
+  })
+);
+var ImgbbUploadDataDef = defineSchema(
+  z.object({
+    id: z.string(),
+    title: z.string(),
+    url_viewer: z.string(),
+    url: z.string(),
+    display_url: z.string(),
+    width: z.string(),
+    height: z.string(),
+    size: z.string(),
+    time: z.string(),
+    expiration: z.string(),
+    image: ImgbbAssetDef.schema,
+    thumb: ImgbbAssetDef.schema,
+    medium: ImgbbAssetDef.schema,
+    delete_url: z.string()
+  })
+);
+var InsertWineResultDef = defineSchema(
+  z.object({
+    insertado_id: z.string().nullable(),
+    error: z.string().nullable(),
+    image: z.union([ImgbbUploadDataDef.schema, ReusedWineImageDef.schema]).optional(),
+    deduplicated: z.boolean().optional()
+  })
+);
+
+// src/index.ts
+var ClientOptionsSchema = ClientOptionsDef.schema;
+var ApiErrorSchema = ApiErrorDef.schema;
+var LoginDataSchema = LoginDataDef.schema;
+var RegisterDataSchema = RegisterDataDef.schema;
+var MagicLinkRequestDataSchema = MagicLinkRequestDataDef.schema;
+var AuthResponseSchema = AuthResponseDef.schema;
+var ApiKeySchema = ApiKeyDef.schema;
+var MagicLinkResponseSchema = MagicLinkResponseDef.schema;
+var ValidateSessionResponseSchema = ValidateSessionResponseDef.schema;
+var SessionDataSchema = SessionDataDef.schema;
+var ActivityLogSchema = ActivityLogDef.schema;
+var RollbackLogSchema = RollbackLogDef.schema;
+var RealtimeOptionsSchema = RealtimeOptionsDef.schema;
+var WineSchema = WineDef.schema;
+var WineDetailsSchema = WineDetailsDef.schema;
+var WineDataSchema = WineDataDef.schema;
+var CreateWineSchema = CreateWineDef.schema;
+var EditWineSchema = EditWineDef.schema;
+var BulkInsertWinesSchema = BulkInsertWinesDef.schema;
+var BulkInsertWinesResultSchema = BulkInsertWinesResultDef.schema;
+var ReusedWineImageSchema = ReusedWineImageDef.schema;
+var ImgbbAssetSchema = ImgbbAssetDef.schema;
+var ImgbbUploadDataSchema = ImgbbUploadDataDef.schema;
+var InsertWineResultSchema = InsertWineResultDef.schema;
+export {
+  ActivityLogSchema,
+  ApiErrorSchema,
+  ApiKeySchema,
+  AuthResponseSchema,
+  BulkInsertWinesResultSchema,
+  BulkInsertWinesSchema,
+  ClientOptionsSchema,
+  CreateWineSchema,
+  EditWineSchema,
+  ImgbbAssetSchema,
+  ImgbbUploadDataSchema,
+  InsertWineResultSchema,
+  LoginDataSchema,
+  MagicLinkRequestDataSchema,
+  MagicLinkResponseSchema,
+  RealtimeOptionsSchema,
+  RegisterDataSchema,
+  ReusedWineImageSchema,
+  RollbackLogSchema,
+  SessionDataSchema,
+  ValidateSessionResponseSchema,
+  WineClient,
+  WineDataSchema,
+  WineDetailsSchema,
+  WineSchema,
+  createClient,
+  createWsImageFile
+};

package/dist/test.quokka.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.quokka.js

@@ -0,0 +1,32 @@
+import { WineClient } from './client';
+const client = new WineClient({
+    baseUrl: 'http://localhost:3000',
+});
+async function main() {
+    const authResult = await client.auth.login({
+        email: 'juanitogaming2707@gmail.com',
+        password: 'Prom_2019',
+    });
+    if (!authResult.success) {
+        console.error(authResult.error.message, authResult.error.code, authResult.error.statusCode);
+        return;
+    }
+    const apiKey = authResult.data.apiKey?.key;
+    if (apiKey) {
+        client.setApiKey(apiKey);
+        console.log('✅ ApiKey configurada');
+    }
+    await client.connectRealtime();
+    console.log('✅ Socket conectado');
+    const wines = await client.realtime.getWines();
+    if (!wines.success) {
+        console.error(wines.error.message, wines.error.code, wines.error.statusCode);
+        return;
+    }
+    console.log(wines.data);
+    console.log('✅ Vinos obtenidos:', wines.data.length);
+    console.log('Primera entrada:', wines.data[0]);
+}
+main().catch(err => {
+    console.error('❌ Error inesperado:', err);
+});

package/dist/types/_helpers.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare function defineSchema<S extends z.ZodTypeAny>(schema: S): {
+    schema: S;
+    type: z.infer<S>;
+};

package/dist/types/_helpers.js

@@ -0,0 +1,5 @@
+export function defineSchema(schema) {
+    return {
+        schema,
+    };
+}