@kadoa/node-sdk 0.12.0 → 0.13.0

package/dist/index.js

@@ -26,7 +26,9 @@ var KadoaErrorCode = {
   AUTH_ERROR: "AUTH_ERROR",
   VALIDATION_ERROR: "VALIDATION_ERROR",
   BAD_REQUEST: "BAD_REQUEST",
-  NOT_FOUND: "NOT_FOUND"};
+  NOT_FOUND: "NOT_FOUND",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
 var _KadoaSdkException = class _KadoaSdkException extends Error {
   constructor(message, options) {
     super(message);
@@ -108,7 +110,10 @@ _KadoaSdkException.ERROR_MESSAGES = {
   // Schema specific errors
   SCHEMA_NOT_FOUND: "Schema not found",
   SCHEMA_FETCH_ERROR: "Failed to fetch schema",
-  SCHEMAS_FETCH_ERROR: "Failed to fetch schemas"
+  SCHEMAS_FETCH_ERROR: "Failed to fetch schemas",
+  SCHEMA_CREATE_FAILED: "Failed to create schema",
+  SCHEMA_UPDATE_FAILED: "Failed to update schema",
+  SCHEMA_DELETE_FAILED: "Failed to delete schema"
 };
 var KadoaSdkException = _KadoaSdkException;
 var ERROR_MESSAGES = KadoaSdkException.ERROR_MESSAGES;
@@ -4054,7 +4059,7 @@ var Configuration = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.12.0";
+var SDK_VERSION = "0.13.0";
 var SDK_NAME = "kadoa-node-sdk";
 var SDK_LANGUAGE = "node";
 
@@ -4490,12 +4495,197 @@ var NotificationsModule = class {
     return this.settingsService;
   }
 };
+var _SchemaBuilder = class _SchemaBuilder {
+  constructor() {
+    this.fields = [];
+  }
+  entity(entityName) {
+    this.entityName = entityName;
+    return this;
+  }
+  /**
+   * Add a structured field to the schema
+   * @param name - Field name (alphanumeric only)
+   * @param description - Field description
+   * @param dataType - Data type (STRING, NUMBER, BOOLEAN, etc.)
+   * @param options - Optional field configuration
+   */
+  field(name, description, dataType, options) {
+    this.validateFieldName(name);
+    const requiresExample = _SchemaBuilder.TYPES_REQUIRING_EXAMPLE.includes(dataType);
+    if (requiresExample && !options?.example) {
+      throw new KadoaSdkException(
+        `Field "${name}" with type ${dataType} requires an example`,
+        { code: "VALIDATION_ERROR", details: { name, dataType } }
+      );
+    }
+    this.fields.push({
+      name,
+      description,
+      dataType,
+      fieldType: "SCHEMA",
+      example: options?.example,
+      isKey: options?.isKey
+    });
+    return this;
+  }
+  /**
+   * Add a classification field to categorize content
+   * @param name - Field name (alphanumeric only)
+   * @param description - Field description
+   * @param categories - Array of category definitions
+   */
+  classify(name, description, categories) {
+    this.validateFieldName(name);
+    this.fields.push({
+      name,
+      description,
+      fieldType: "CLASSIFICATION",
+      categories
+    });
+    return this;
+  }
+  /**
+   * Add raw page content to extract
+   * @param name - Raw content format(s): "html", "markdown", or "url"
+   */
+  raw(name) {
+    const names = Array.isArray(name) ? name : [name];
+    for (const name2 of names) {
+      const fieldName = `raw${esToolkit.upperFirst(esToolkit.camelCase(name2))}`;
+      if (this.fields.some((field) => field.name === fieldName)) {
+        continue;
+      }
+      this.fields.push({
+        name: fieldName,
+        description: `Raw page content in ${name2.toUpperCase()} format`,
+        fieldType: "METADATA",
+        metadataKey: name2
+      });
+    }
+    return this;
+  }
+  build() {
+    if (!this.entityName) {
+      throw new KadoaSdkException("Entity name is required", {
+        code: "VALIDATION_ERROR",
+        details: { entityName: this.entityName }
+      });
+    }
+    return {
+      entityName: this.entityName,
+      fields: this.fields
+    };
+  }
+  validateFieldName(name) {
+    if (!_SchemaBuilder.FIELD_NAME_PATTERN.test(name)) {
+      throw new KadoaSdkException(
+        `Field name "${name}" must be alphanumeric only (no underscores or special characters)`,
+        {
+          code: "VALIDATION_ERROR",
+          details: { name, pattern: "^[A-Za-z0-9]+$" }
+        }
+      );
+    }
+    const lowerName = name.toLowerCase();
+    if (this.fields.some((f) => f.name.toLowerCase() === lowerName)) {
+      throw new KadoaSdkException(`Duplicate field name: "${name}"`, {
+        code: "VALIDATION_ERROR",
+        details: { name }
+      });
+    }
+  }
+};
+_SchemaBuilder.FIELD_NAME_PATTERN = /^[A-Za-z0-9]+$/;
+_SchemaBuilder.TYPES_REQUIRING_EXAMPLE = [
+  "STRING",
+  "IMAGE",
+  "LINK",
+  "OBJECT",
+  "ARRAY"
+];
+var SchemaBuilder = _SchemaBuilder;
 
 // src/modules/schemas.module.ts
+var SchemaBuilderWithCreate = class extends SchemaBuilder {
+  constructor(entityName, service) {
+    super();
+    this.service = service;
+    this.entity(entityName);
+  }
+  /**
+   * Create the schema directly in Kadoa
+   * @param name - Optional schema name (defaults to entity name)
+   * @returns Promise resolving to the created schema
+   */
+  async create(name) {
+    const built = this.build();
+    return this.service.createSchema({
+      name: name || built.entityName,
+      entity: built.entityName,
+      fields: built.fields
+    });
+  }
+};
 var SchemasModule = class {
   constructor(service) {
     this.service = service;
   }
+  /**
+   * Create a new schema builder for fluent schema definition
+   * @param entityName - The name of the entity this schema represents
+   * @returns A new SchemaBuilder instance with the entity name already set
+   * @example Build then create
+   * ```typescript
+   * const schema = kadoa.schema.builder("Product")
+   *   .field("title", "Product name", "STRING", { example: "iPhone 15" })
+   *   .field("price", "Product price", "NUMBER")
+   *   .build();
+   *
+   * await kadoa.schema.create(schema);
+   * ```
+   *
+   * @example Fluent chain with create
+   * ```typescript
+   * const schema = await kadoa.schema.builder("Product")
+   *   .field("title", "Product name", "STRING", { example: "iPhone 15" })
+   *   .field("price", "Product price", "NUMBER")
+   *   .create("Product Schema");
+   * ```
+   */
+  builder(entityName) {
+    return new SchemaBuilderWithCreate(entityName, this.service);
+  }
+  /**
+   * Get a schema by ID
+   */
+  async get(schemaId) {
+    return this.service.getSchema(schemaId);
+  }
+  /**
+   * List all schemas
+   */
+  async list() {
+    return this.service.listSchemas();
+  }
+  /**
+   * Create a new schema from a body
+   */
+  async create(body) {
+    return this.service.createSchema(body);
+  }
+  /**
+   * Update an existing schema
+   */
+  async update(schemaId, body) {
+    return this.service.updateSchema(schemaId, body);
+  }
+  /**
+   * Delete a schema
+   */
+  async delete(schemaId) {
+    return this.service.deleteSchema(schemaId);
+  }
 };
 
 // src/modules/user.module.ts
@@ -5312,7 +5502,6 @@ var SchemasService = class {
   }
   /**
    * Get a schema by ID
-   * //todo: use proper schema type for response from generated client (when avaialble)
    */
   async getSchema(schemaId) {
     debug4("Fetching schema with ID: %s", schemaId);
@@ -5331,6 +5520,49 @@ var SchemasService = class {
     }
     return schemaData;
   }
+  /**
+   * List all schemas
+   */
+  async listSchemas() {
+    const response = await this.schemasApi.v4SchemasGet();
+    return response.data.data;
+  }
+  /**
+   * Create a new schema
+   */
+  async createSchema(body) {
+    debug4("Creating schema with name: %s", body.name);
+    const response = await this.schemasApi.v4SchemasPost({
+      createSchemaBody: body
+    });
+    const schemaId = response.data.schemaId;
+    if (!schemaId) {
+      throw new KadoaSdkException(ERROR_MESSAGES.SCHEMA_CREATE_FAILED, {
+        code: KadoaErrorCode.INTERNAL_ERROR
+      });
+    }
+    return this.getSchema(schemaId);
+  }
+  /**
+   * Update an existing schema
+   */
+  async updateSchema(schemaId, body) {
+    debug4("Updating schema with ID: %s", schemaId);
+    await this.schemasApi.v4SchemasSchemaIdPut({
+      schemaId,
+      updateSchemaBody: body
+    });
+    return this.getSchema(schemaId);
+  }
+  /**
+   * Delete a schema
+   */
+  async deleteSchema(schemaId) {
+    debug4("Deleting schema with ID: %s", schemaId);
+    await this.schemasApi.v4SchemasSchemaIdDelete({
+      schemaId
+    });
+  }
 };
 
 // src/internal/domains/notifications/notification-setup.service.ts
@@ -5801,12 +6033,12 @@ var EntityResolverService = class {
         fields: entityPrediction.fields
       };
     } else if (entityConfig) {
-      if ("schemId" in entityConfig) {
+      if ("schemaId" in entityConfig) {
         const schema = await this.schemasService.getSchema(
-          entityConfig.schemId
+          entityConfig.schemaId
         );
         return {
-          entity: schema.entity,
+          entity: schema.entity ?? "",
           fields: schema.schema
         };
       } else if ("name" in entityConfig && "fields" in entityConfig) {
@@ -5867,187 +6099,6 @@ var EntityResolverService = class {
     }
   }
 };
-
-// src/internal/domains/extraction/builders/extraction-builder.ts
-var ExtractionBuilder = class {
-  constructor() {
-    this.fields = [];
-  }
-  /**
-   * Start defining a custom schema with fields
-   * @param name - The entity name (e.g., "Product", "Article")
-   */
-  schema(name) {
-    if (this.schemaId) {
-      throw new KadoaSdkException(
-        "Cannot use schema() after useSchema() - they are mutually exclusive",
-        { code: "VALIDATION_ERROR" }
-      );
-    }
-    this.schemaName = name;
-    return new SchemaBuilder(this);
-  }
-  /**
-   * Use an existing schema by ID
-   * @param schemaId - The schema ID to reference
-   */
-  useSchema(schemaId) {
-    if (this.schemaName || this.fields.length > 0) {
-      throw new KadoaSdkException(
-        "Cannot use useSchema() after schema() or field definitions - they are mutually exclusive",
-        { code: "VALIDATION_ERROR" }
-      );
-    }
-    this.schemaId = schemaId;
-    return this;
-  }
-  /**
-   * Extract raw page content without transformation
-   * @param format - Raw content format(s): "html", "markdown", or "url"
-   */
-  raw(format) {
-    const formats = Array.isArray(format) ? format : [format];
-    const nameMap = {
-      html: "rawHtml",
-      markdown: "rawMarkdown",
-      url: "rawUrl"
-    };
-    const metadataKeyMap = {
-      html: "HTML",
-      markdown: "MARKDOWN",
-      url: "PAGE_URL"
-    };
-    for (const f of formats) {
-      const fieldName = nameMap[f];
-      if (this.fields.some((field) => field.name === fieldName)) {
-        continue;
-      }
-      this.fields.push({
-        name: fieldName,
-        description: `Raw page content in ${f.toUpperCase()} format`,
-        fieldType: "METADATA",
-        metadataKey: metadataKeyMap[f]
-      });
-    }
-    return this;
-  }
-  /**
-   * Get the fields array (internal use)
-   */
-  getFields() {
-    return this.fields;
-  }
-  /**
-   * Get the schema name (internal use)
-   */
-  getSchemaName() {
-    return this.schemaName;
-  }
-  /**
-   * Get the schema ID (internal use)
-   */
-  getSchemaId() {
-    return this.schemaId;
-  }
-};
-var _SchemaBuilder = class _SchemaBuilder extends ExtractionBuilder {
-  constructor(parentBuilder) {
-    super();
-    this.fields = parentBuilder.getFields();
-    this.schemaName = parentBuilder.getSchemaName();
-    this.schemaId = parentBuilder.getSchemaId();
-  }
-  /**
-   * Add a structured field to the schema
-   * @param name - Field name (alphanumeric only)
-   * @param description - Field description
-   * @param dataType - Data type (STRING, NUMBER, BOOLEAN, etc.)
-   * @param options - Optional field configuration
-   */
-  field(name, description, dataType, options) {
-    if (!_SchemaBuilder.FIELD_NAME_PATTERN.test(name)) {
-      throw new KadoaSdkException(
-        `Field name "${name}" must be alphanumeric only (no underscores or special characters)`,
-        {
-          code: "VALIDATION_ERROR",
-          details: { name, pattern: "^[A-Za-z0-9]+$" }
-        }
-      );
-    }
-    const lowerName = name.toLowerCase();
-    if (this.fields.some((f) => f.name.toLowerCase() === lowerName)) {
-      throw new KadoaSdkException(`Duplicate field name: "${name}"`, {
-        code: "VALIDATION_ERROR",
-        details: { name }
-      });
-    }
-    const requiresExample = _SchemaBuilder.TYPES_REQUIRING_EXAMPLE.includes(dataType);
-    if (requiresExample && !options?.example) {
-      throw new KadoaSdkException(
-        `Field "${name}" with type ${dataType} requires an example`,
-        { code: "VALIDATION_ERROR", details: { name, dataType } }
-      );
-    }
-    this.fields.push({
-      name,
-      description,
-      dataType,
-      fieldType: "SCHEMA",
-      example: options?.example,
-      isKey: options?.isKey
-    });
-    return this;
-  }
-  /**
-   * Add a classification field to categorize content
-   * @param name - Field name (alphanumeric only)
-   * @param description - Field description
-   * @param categories - Array of category definitions
-   */
-  classify(name, description, categories) {
-    if (!_SchemaBuilder.FIELD_NAME_PATTERN.test(name)) {
-      throw new KadoaSdkException(
-        `Field name "${name}" must be alphanumeric only (no underscores or special characters)`,
-        {
-          code: "VALIDATION_ERROR",
-          details: { name, pattern: "^[A-Za-z0-9]+$" }
-        }
-      );
-    }
-    const lowerName = name.toLowerCase();
-    if (this.fields.some((f) => f.name.toLowerCase() === lowerName)) {
-      throw new KadoaSdkException(`Duplicate field name: "${name}"`, {
-        code: "VALIDATION_ERROR",
-        details: { name }
-      });
-    }
-    this.fields.push({
-      name,
-      description,
-      fieldType: "CLASSIFICATION",
-      categories
-    });
-    return this;
-  }
-  /**
-   * Add raw page content alongside structured fields
-   * @param format - Raw content format(s): "html", "markdown", or "url"
-   */
-  raw(format) {
-    return super.raw(format);
-  }
-};
-_SchemaBuilder.FIELD_NAME_PATTERN = /^[A-Za-z0-9]+$/;
-_SchemaBuilder.TYPES_REQUIRING_EXAMPLE = [
-  "STRING",
-  "IMAGE",
-  "LINK",
-  "OBJECT",
-  "ARRAY"
-];
-var SchemaBuilder = _SchemaBuilder;
-
-// src/internal/domains/extraction/services/extraction-builder.service.ts
 var debug7 = logger.extraction;
 var ExtractionBuilderService = class {
   constructor(workflowsCoreService, entityResolverService, dataFetcherService, notificationSetupService) {
@@ -6083,18 +6134,12 @@ var ExtractionBuilderService = class {
   }) {
     let entity = "ai-detection";
     if (extraction) {
-      const builder = extraction(new ExtractionBuilder());
-      const schemaId = builder.getSchemaId();
-      const schemaName = builder.getSchemaName();
-      const fields = builder.getFields();
-      if (schemaId) {
-        entity = { schemId: schemaId };
-      } else if (schemaName && fields.length > 0) {
-        entity = { name: schemaName, fields };
-      } else if (fields.length > 0 && !schemaName) {
-        entity = { name: "RawExtraction", fields };
+      const result = extraction(new SchemaBuilder());
+      if ("schemaId" in result) {
+        entity = { schemaId: result.schemaId };
       } else {
-        entity = "ai-detection";
+        const builtSchema = result.build();
+        entity = { name: builtSchema.entityName, fields: builtSchema.fields };
       }
     }
     this._options = {
@@ -6138,7 +6183,7 @@ var ExtractionBuilderService = class {
   async create() {
     assert__default.default(this._options, "Options are not set");
     const { urls, name, description, navigationMode, entity } = this.options;
-    const resolvedEntity = typeof entity === "object" && "schemId" in entity ? void 0 : await this.entityResolverService.resolveEntity(entity, {
+    const resolvedEntity = typeof entity === "object" && "schemaId" in entity ? void 0 : await this.entityResolverService.resolveEntity(entity, {
       link: urls[0],
       location: this._options.location,
       navigationMode
@@ -6155,7 +6200,7 @@ var ExtractionBuilderService = class {
       description,
       navigationMode,
       monitoring: this._monitoringOptions,
-      schemaId: typeof entity === "object" && "schemId" in entity ? entity.schemId : void 0,
+      schemaId: typeof entity === "object" && "schemaId" in entity ? entity.schemaId : void 0,
       entity: resolvedEntity.entity,
       fields: resolvedEntity.fields,
       autoStart: false,
@@ -6465,6 +6510,7 @@ exports.ERROR_MESSAGES = ERROR_MESSAGES;
 exports.KadoaClient = KadoaClient;
 exports.KadoaHttpException = KadoaHttpException;
 exports.KadoaSdkException = KadoaSdkException;
+exports.SchemaBuilder = SchemaBuilder;
 exports.SchemasModule = SchemasModule;
 exports.ValidationModule = ValidationModule;
 exports.pollUntil = pollUntil;