@superblocksteam/vite-plugin-file-sync 1.99.99-next.3 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/ai-service/skills/system/superblocks-api/references/rest-apis.generated.js

@@ -0,0 +1,276 @@
+// Auto-generated from src/ai-service/skills/system/superblocks-api/references/rest-apis.md
+// Do not edit directly - edit the .md file instead
+export const content = `# REST API Integrations
+
+Reference documentation for working with REST APIs and OpenAPI integrations in Superblocks.
+
+## REST API vs OpenAPI
+
+**Use RestApi** when:
+
+- Making calls to custom endpoints
+- No OpenAPI spec available
+- Simple GET/POST operations
+
+**Use OpenApi** when:
+
+- Integration metadata shows \`spec: "openapi"\` or \`specType: "OPEN_API_SPEC"\`
+- Working with documented APIs (Stripe, Twilio, etc.)
+- Need type-safe operations
+
+## RestApi Class
+
+\`\`\`typescript
+import { RestApi } from "@superblocksteam/library";
+
+new RestApi("fetch_data", "rest-integration-id", {
+  method: "GET",
+  url: "https://api.example.com/data",
+  params: { page: "1", limit: "10" },
+  headers: { "X-Custom-Header": "value" },
+});
+\`\`\`
+
+### Dynamic Configuration
+
+\`\`\`typescript
+new RestApi("create_item", "rest-id", {
+  method: "POST",
+  url: ({ baseUrl }: { baseUrl: string }) => \`\${baseUrl}/items\`,
+  params: ({ page }: { page: number }) => ({ page: String(page) }),
+  headers: ({ authToken }: { authToken: string }) => ({
+    Authorization: \`Bearer \${authToken}\`,
+    "Content-Type": "application/json",
+  }),
+  body: ({ itemData }: { itemData: object }) => JSON.stringify(itemData),
+});
+\`\`\`
+
+### Common REST Patterns
+
+\`\`\`typescript
+// GET with query params
+new RestApi("search", "rest-id", {
+  method: "GET",
+  url: "https://api.example.com/search",
+  params: ({ query, page }: { query: string; page: number }) => ({
+    q: query,
+    page: String(page),
+    limit: "20",
+  }),
+});
+
+// POST with JSON body
+new RestApi("create", "rest-id", {
+  method: "POST",
+  url: "https://api.example.com/items",
+  headers: { "Content-Type": "application/json" },
+  body: ({ data }: { data: object }) => JSON.stringify(data),
+});
+
+// PUT for updates
+new RestApi("update", "rest-id", {
+  method: "PUT",
+  url: ({ id }: { id: string }) => \`https://api.example.com/items/\${id}\`,
+  headers: { "Content-Type": "application/json" },
+  body: ({ data }: { data: object }) => JSON.stringify(data),
+});
+
+// DELETE
+new RestApi("delete", "rest-id", {
+  method: "DELETE",
+  url: ({ id }: { id: string }) => \`https://api.example.com/items/\${id}\`,
+});
+\`\`\`
+
+## OpenApi Class
+
+\`\`\`typescript
+import { OpenApi } from "@superblocksteam/library";
+
+new OpenApi("list_customers", "stripe-integration-id", {
+  operation: "listCustomers",
+  params: { limit: 10 },
+});
+\`\`\`
+
+### OpenAPI Operations
+
+Operation names are defined by the API spec. Common patterns:
+
+- \`list{Resource}\` - List all resources
+- \`get{Resource}\` - Get a single resource
+- \`create{Resource}\` - Create a resource
+- \`update{Resource}\` - Update a resource
+- \`delete{Resource}\` - Delete a resource
+
+### Dynamic OpenAPI Params
+
+\`\`\`typescript
+new OpenApi("get_customer", "stripe-id", {
+  operation: "getCustomer",
+  params: ({ customerId }: { customerId: string }) => ({
+    customer_id: customerId,
+  }),
+});
+\`\`\`
+
+## Response Handling
+
+REST and OpenAPI responses are available via \`.output\`:
+
+\`\`\`typescript
+new RestApi("fetch", "rest-id", { ... }),
+
+new JavaScript("process", {
+  fn: ({ fetch }) => {
+    const data = fetch.output;
+    // For REST APIs, output is typically the JSON response
+    // For OpenAPI, output structure depends on the operation
+    return data.items.map(item => item.name);
+  }
+})
+\`\`\`
+
+## Error Handling
+
+HTTP errors (4xx, 5xx) are captured in the output:
+
+\`\`\`typescript
+new TryCatch("safe_api_call", {
+  try: [
+    new RestApi("risky_call", "rest-id", {
+      method: "POST",
+      url: "https://api.example.com/sensitive",
+    }),
+  ],
+  catch: [
+    new JavaScript("handle_error", {
+      fn: ({ apiError }) => ({
+        success: false,
+        error: apiError.value.message,
+        statusCode: apiError.value.statusCode,
+      }),
+    }),
+  ],
+  variables: { error: "apiError" },
+});
+\`\`\`
+
+## Pagination Patterns
+
+### Cursor-Based Pagination
+
+\`\`\`typescript
+(new Variables("state", [
+  { key: "allItems", value: () => [] },
+  { key: "cursor", value: () => null },
+  { key: "hasMore", value: () => true },
+]),
+  new Loop("paginate", {
+    type: "TYPE_FOREACH",
+    over: () => [...Array(100).keys()],
+    variables: { item: "_", index: "i" },
+    blocks: [
+      new Conditional("check_done", {
+        if: {
+          when: ({ hasMore }) => !hasMore.value,
+          then: [new Break("exit", { condition: () => true })],
+        },
+      }),
+      new RestApi("fetch_page", "rest-id", {
+        method: "GET",
+        url: "https://api.example.com/items",
+        params: ({ cursor }) => (cursor.value ? { cursor: cursor.value } : {}),
+      }),
+      new JavaScript("accumulate", {
+        fn: ({ fetch_page, allItems, cursor, hasMore }) => {
+          const response = fetch_page.output;
+          allItems.set([...allItems.value, ...response.items]);
+          cursor.set(response.nextCursor);
+          hasMore.set(!!response.nextCursor);
+          return allItems.value;
+        },
+      }),
+    ],
+  }));
+\`\`\`
+
+### Offset-Based Pagination
+
+\`\`\`typescript
+(new Variables("state", [
+  { key: "allItems", value: () => [] },
+  { key: "page", value: () => 0 },
+  { key: "hasMore", value: () => true },
+]),
+  new Loop("paginate", {
+    type: "TYPE_WHILE",
+    condition: ({ hasMore }) => hasMore.value,
+    blocks: [
+      new RestApi("fetch_page", "rest-id", {
+        method: "GET",
+        url: "https://api.example.com/items",
+        params: ({ page }) => ({
+          offset: String(page.value * 100),
+          limit: "100",
+        }),
+      }),
+      new JavaScript("accumulate", {
+        fn: ({ fetch_page, allItems, page, hasMore }) => {
+          const items = fetch_page.output.items;
+          allItems.set([...allItems.value, ...items]);
+          page.set(page.value + 1);
+          hasMore.set(items.length === 100);
+          return allItems.value;
+        },
+      }),
+    ],
+  }));
+\`\`\`
+
+## Authentication Patterns
+
+### Bearer Token
+
+\`\`\`typescript
+new RestApi("authenticated_call", "rest-id", {
+  method: "GET",
+  url: "https://api.example.com/secure",
+  headers: ({ token }: { token: string }) => ({
+    Authorization: \`Bearer \${token}\`,
+  }),
+});
+\`\`\`
+
+### API Key
+
+\`\`\`typescript
+new RestApi("api_key_call", "rest-id", {
+  method: "GET",
+  url: "https://api.example.com/data",
+  headers: ({ apiKey }: { apiKey: string }) => ({
+    "X-API-Key": apiKey,
+  }),
+});
+\`\`\`
+
+### Basic Auth
+
+\`\`\`typescript
+new RestApi("basic_auth_call", "rest-id", {
+  method: "GET",
+  url: "https://api.example.com/data",
+  headers: ({
+    username,
+    password,
+  }: {
+    username: string;
+    password: string;
+  }) => ({
+    Authorization: \`Basic \${Buffer.from(\`\${username}:\${password}\`).toString("base64")}\`,
+  }),
+});
+\`\`\`
+`;
+//# sourceMappingURL=rest-apis.generated.js.map

package/dist/ai-service/skills/system/superblocks-api/references/rest-apis.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-apis.generated.js","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/rest-apis.generated.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,mDAAmD;AAEnD,MAAM,CAAC,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgRtB,CAAC"}

package/dist/ai-service/skills/system/superblocks-api/references/sql-databases.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const content = "# SQL Database Integrations\n\nReference documentation for working with SQL databases in Superblocks APIs.\n\n## Supported Databases\n\n- PostgreSQL, MySQL, MariaDB, MSSQL\n- Snowflake, Redshift, BigQuery, Athena\n- Databricks, SingleStore, Lakebase\n- CockroachDB, YugabyteDB, OracleDB\n\n## SQL Block Classes\n\n```typescript\n// Available SQL integrations\nimport {\n  PostgreSQL,\n  MySQL,\n  MariaDB,\n  MSSQL,\n  Snowflake,\n  Redshift,\n  BigQuery,\n  Athena,\n  Databricks,\n  SingleStore,\n  OracleDB,\n} from \"@superblocksteam/library\";\n```\n\n## Basic Usage\n\n```typescript\nnew PostgreSQL(\"get_users\", \"postgres-integration-id\", {\n  statement: \"SELECT * FROM users WHERE active = true LIMIT 100\",\n});\n```\n\n## Parameterized Queries\n\n### SQL Security Priority\n\n**ALWAYS prefer parameterized queries over string interpolation for user input values.**\n\nUse `parameters: \"[var1, var2]\"` with the database-specific SQL placeholders:\n\n| Database                                    | Placeholder Syntax     | Example                                     |\n| ------------------------------------------- | ---------------------- | ------------------------------------------- |\n| PostgreSQL, Redshift, CockroachDB           | `$1`, `$2`, `$3`       | `WHERE id = $1 AND status = $2`             |\n| MySQL, MariaDB, Snowflake, BigQuery, Athena | `?`, `?`, `?`          | `WHERE id = ? AND status = ?`               |\n| MSSQL                                       | `@PARAM_1`, `@PARAM_2` | `WHERE id = @PARAM_1 AND status = @PARAM_2` |\n| Databricks                                  | `:PARAM_1`, `:PARAM_2` | `WHERE id = :PARAM_1 AND status = :PARAM_2` |\n| OracleDB                                    | `:1`, `:2`, `:3`       | `WHERE id = :1 AND status = :2`             |\n\nOnly use binding functions for truly dynamic SQL elements like table/column names.\n\n### Parameters Syntax vs Statement Syntax\n\n**Important:** `parameters` is a JavaScript expression string that gets evaluated directly. Do NOT use `${}` interpolation or binding functions.\n\n```typescript\n// \u274C WRONG - Don't use ${} interpolation in parameters\nparameters: \"[${build_query.output.userId}, ${searchTerm}]\";\n\n// \u274C WRONG - Don't use binding functions for parameters\nparameters: ({ build_query }) => JSON.stringify(build_query.output.params);\n\n// \u2705 CORRECT - Write expressions directly (they get evaluated as JS)\nparameters: \"[build_query.output.userId, searchTerm, limit]\";\n\n// \u2705 CORRECT - Reference block output array directly\nparameters: \"build_query.output.params\";\n```\n\nThis is different from `statement`, where binding functions with `${}` ARE used to interpolate values into SQL.\n\n### String Interpolation (Alternative)\n\nFor simpler cases, string interpolation also works:\n\n```typescript\n// \u2705 CORRECT - String interpolation for WHERE clauses\nnew PostgreSQL(\"search\", \"postgres-id\", {\n  statement: ({ searchTerm, limit }: { searchTerm: string; limit: number }) =>\n    `SELECT * FROM users WHERE name ILIKE '%${searchTerm}%' LIMIT ${limit}`,\n});\n\n// \u2705 CORRECT - For INSERT statements\nnew PostgreSQL(\"insert_user\", \"postgres-id\", {\n  statement: ({ name, email }: { name: string; email: string }) =>\n    `INSERT INTO users (name, email) VALUES ('${name}', '${email}') RETURNING *`,\n});\n```\n\n### Dynamic SQL with Optional Filters\n\nUse the `parameters` array with the \"OR NULL\" pattern for optional filters:\n\n- `WHERE (column = $1 OR $1::type IS NULL)` makes the condition a no-op when parameter is null\n- Cast parameters to their type when checking for NULL (PostgreSQL can't infer types from NULL values)\n- Always pass all parameters, using null for unused filters\n- NEVER interpolate user values directly into SQL strings\n\n## Best Practices\n\n### 1. ONE Query Per Block Rule\n\nEach SQL block (PostgreSQL, Snowflake, MySQL, MicrosoftSql, Databricks) can execute **ONLY ONE SQL query**.\n\n\u274C **WRONG - Multiple queries in one block:**\n\n```sql\nUPDATE users SET status = 'active';\nDELETE FROM logs WHERE created < '2023-01-01';\nINSERT INTO audit VALUES ('done');\n```\n\n\u2705 **CORRECT - One query per block:**\n\n```typescript\n(new PostgreSQL(\"update_status\", \"postgres-id\", {\n  statement: \"UPDATE users SET status = 'active'\",\n}),\n  new PostgreSQL(\"clean_logs\", \"postgres-id\", {\n    statement: \"DELETE FROM logs WHERE created < '2023-01-01'\",\n  }));\n```\n\n### 2. Use Meaningful Block Names\n\n```typescript\n// \u2705 GOOD\nnew PostgreSQL(\"fetch_active_users\", \"pg-id\", { ... })\nnew PostgreSQL(\"insert_order_item\", \"pg-id\", { ... })\n\n// \u274C BAD\nnew PostgreSQL(\"query1\", \"pg-id\", { ... })\nnew PostgreSQL(\"sql\", \"pg-id\", { ... })\n```\n\n### 3. Always Specify Columns\n\n```typescript\n// \u2705 PREFERRED - Explicit columns\nSELECT id, name, email, created_at FROM users\n\n// \u26A0\uFE0F AVOID - Select all\nSELECT * FROM users\n```\n\n### 4. Always Add Defensive Row Limits\n\nAlways include a row limit clause to prevent runaway queries. Use 100 as the default unless user specifies otherwise.\n\nDifferent SQL dialects have different syntax:\n\n- **MySQL/PostgreSQL/SQLite**: `LIMIT N`\n- **SQL Server**: `SELECT TOP N`\n- **ANSI SQL (SQL Server, Oracle, DB2)**: `OFFSET 0 ROWS FETCH NEXT N ROWS ONLY`\n\n```sql\n-- \u2705 PostgreSQL/MySQL\nSELECT * FROM orders ORDER BY created_at DESC LIMIT 100;\n\n-- \u2705 SQL Server\nSELECT TOP 100 * FROM orders ORDER BY created_at DESC;\n\n-- \u2705 ANSI SQL (SQL Server with ORDER BY)\nSELECT * FROM orders ORDER BY created_at DESC OFFSET 0 ROWS FETCH NEXT 100 ROWS ONLY;\n\n-- \u274C Avoid unlimited queries\nSELECT * FROM orders ORDER BY created_at DESC;  -- Can timeout or crash\n```\n\n### 5. Sort, Don't Filter by Date (Default)\n\nDo NOT add automatic date filters (e.g., \"last 90 days\") unless the user explicitly requests them. This is a common cause of unexpected empty SQL results.\n\n```sql\n-- \u2705 Default approach\nSELECT * FROM orders ORDER BY created_at DESC LIMIT 100;\n\n-- \u274C Avoid automatic filtering\nSELECT * FROM orders WHERE created_at >= CURRENT_DATE - INTERVAL '90 days';  -- Can return empty results\n```\n\nOnly add date WHERE clauses when users explicitly ask for time-based filtering.\n\n### 6. Handle NULL Values\n\n```typescript\n// \u2705 Use COALESCE for default values\nSELECT COALESCE(description, 'No description') as description FROM products\n\n// \u2705 Use IS NULL / IS NOT NULL\nSELECT * FROM users WHERE deleted_at IS NULL\n```\n\n## Database-Specific Notes\n\n### PostgreSQL\n\n```typescript\n// Array operations\nnew PostgreSQL(\"array_query\", \"pg-id\", {\n  statement: ({ tags }: { tags: string[] }) =>\n    `SELECT * FROM posts WHERE tags && ARRAY[${tags.map((t) => `'${t}'`).join(\",\")}]`,\n});\n\n// JSON operations\nnew PostgreSQL(\"json_query\", \"pg-id\", {\n  statement: \"SELECT data->>'name' as name FROM json_data\",\n});\n```\n\n- Use schema-qualified names: `schema.table` or `\"schema\".\"table\"`\n- Case sensitivity: Unquoted identifiers are lowercase\n- Use `::type` for type casting\n\n#### Custom Type Casts (Enums, Composite Types)\n\n**When casting parameters, always use the actual column type \u2014 not `text` or other generic types.**\n\nPostgreSQL columns can use custom types such as enums (`billing_plan_enum`, `order_status_enum`) or composite types. When `grepMetadata` reports a column type that is not a built-in type, you **must** use that exact type in SQL casts. Casting to `text` or `text[]` will fail with an `operator does not exist` error.\n\n**Rule:** Before writing any `::type` cast, check the actual column type via `grepMetadata`. If the column type is a custom type (e.g., `billing_plan_enum`), cast to that type, not `text`.\n\n```sql\n-- grepMetadata shows: billing.plan has type \"billing_plan_enum\"\n\n-- \u2705 CORRECT - Cast to the actual column type\nWHERE bf.plan = ANY($3::billing_plan_enum[])\n\n-- \u274C WRONG - Casting to text[] for an enum column\nWHERE bf.plan = ANY($3::text[])\n-- ERROR: operator does not exist: billing_plan_enum = text\n```\n\nThis applies to all custom types, not just enums:\n\n```sql\n-- Column type is \"order_status_enum\"\nWHERE o.status = ANY($1::order_status_enum[])  -- \u2705\nWHERE o.status = ANY($1::text[])               -- \u274C\n\n-- Column type is \"priority_level\" (custom enum)\nWHERE t.priority = $2::priority_level           -- \u2705\nWHERE t.priority = $2::text                     -- \u274C\n```\n\n**Why this matters:** PostgreSQL does not implicitly cast between custom types and `text`. Even though enum values look like strings and `SELECT DISTINCT` returns them as plain strings, the column's actual type must be used in parameter casts. The `grepMetadata` tool returns the real type name \u2014 always use it.\n\n### Snowflake\n\n```typescript\n// Use QUALIFY for window function filtering\nnew Snowflake(\"ranked_query\", \"snowflake-id\", {\n  statement: `\n    SELECT *, ROW_NUMBER() OVER (PARTITION BY category ORDER BY sales DESC) as rank\n    FROM products\n    QUALIFY rank <= 3\n  `,\n});\n```\n\n**Snowflake Two-Part Naming:** Snowflake uses `schema.table`\n\nWhen you see Snowflake metadata where tables have a `schema` property, **you MUST qualify table names**:\n\n```sql\n-- If table has schema property \"MASTERDATA\"\nSELECT * FROM MASTERDATA.PRODUCTLINE  -- \u2705 Fully qualified\nSELECT * FROM PRODUCTLINE             -- \u274C Will fail if no default schema\n```\n\n**Rule**: If a table object has a non-empty `schema` property, use `{schema}.{name}` format in your SQL queries.\n\n### Databricks\n\n**Databricks Three-Part Naming:** Databricks uses `catalog.schema.table`\n\nWhen you see Databricks metadata like:\n\n- `uber.default.orders` - Use the FULL path: `uber.default.orders`\n- `production.analytics.users` - Use: `production.analytics.users`\n\n```sql\n-- Metadata shows: uber.default.orders\nSELECT * FROM uber.default.orders     -- \u2705 Full path\nSELECT * FROM uber.orders            -- \u274C Missing schema part\nSELECT * FROM orders                 -- \u274C Missing catalog and schema\n```\n\n**Note:** The word \"default\" in Databricks paths is NOT optional - it's the actual schema name. Always include all three parts exactly as shown in the metadata.\n\n### BigQuery\n\n```typescript\n// Use backticks for table names, ? placeholders for parameters\nnew BigQuery(\"get_events\", \"bq-id\", {\n  sqlBody:\n    \"SELECT * FROM \\`project.dataset.events\\` WHERE status = ? LIMIT 100\",\n  parameters: \"[statusFilter]\",\n});\n\n// Without parameters\nnew BigQuery(\"get_all\", \"bq-id\", {\n  sqlBody: \"SELECT * FROM \\`project.dataset.table\\` LIMIT 100\",\n});\n```\n\n## Common Patterns\n\n### Pagination\n\n```typescript\nnew PostgreSQL(\"paginated_fetch\", \"pg-id\", {\n  statement: ({ page, pageSize }: { page: number; pageSize: number }) =>\n    `SELECT * FROM orders ORDER BY created_at DESC LIMIT ${pageSize} OFFSET ${(page - 1) * pageSize}`,\n});\n```\n\n### Search with Multiple Conditions\n\n```typescript\nnew PostgreSQL(\"advanced_search\", \"pg-id\", {\n  statement: ({\n    name,\n    status,\n    minAmount,\n  }: {\n    name?: string;\n    status?: string;\n    minAmount?: number;\n  }) => {\n    const conditions = [\"1=1\"];\n    if (name) conditions.push(`name ILIKE '%${name}%'`);\n    if (status) conditions.push(`status = '${status}'`);\n    if (minAmount !== undefined) conditions.push(`amount >= ${minAmount}`);\n    return `SELECT * FROM orders WHERE ${conditions.join(\" AND \")} LIMIT 100`;\n  },\n});\n```\n\n### Batch Insert\n\n```typescript\nnew PostgreSQL(\"batch_insert\", \"pg-id\", {\n  statement: ({ items }: { items: Array<{ name: string; value: number }> }) => {\n    const values = items\n      .map((item) => `('${item.name}', ${item.value})`)\n      .join(\", \");\n    return `INSERT INTO items (name, value) VALUES ${values} RETURNING *`;\n  },\n});\n```\n\n### Upsert (Insert or Update)\n\n```typescript\n// PostgreSQL\nnew PostgreSQL(\"upsert_user\", \"pg-id\", {\n  statement: ({\n    id,\n    name,\n    email,\n  }: {\n    id: string;\n    name: string;\n    email: string;\n  }) =>\n    `INSERT INTO users (id, name, email) \n     VALUES ('${id}', '${name}', '${email}')\n     ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, email = EXCLUDED.email\n     RETURNING *`,\n});\n```\n\n## Error Handling\n\nSQL errors are returned in the block's output. Common errors:\n\n- Syntax errors in SQL\n- Table/column doesn't exist\n- Constraint violations\n- Connection timeouts\n\nFor critical operations, wrap in TryCatch:\n\n```typescript\nnew TryCatch(\"safe_delete\", {\n  try: [\n    new PostgreSQL(\"delete_record\", \"pg-id\", {\n      statement: ({ id }: { id: string }) =>\n        `DELETE FROM sensitive_data WHERE id = '${id}'`,\n    }),\n  ],\n  catch: [\n    new JavaScript(\"log_error\", {\n      fn: ({ deleteError }) => ({\n        success: false,\n        error: deleteError.value.message,\n      }),\n    }),\n  ],\n  variables: { error: \"deleteError\" },\n});\n```\n";
+//# sourceMappingURL=sql-databases.generated.d.ts.map

package/dist/ai-service/skills/system/superblocks-api/references/sql-databases.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-databases.generated.d.ts","sourceRoot":"","sources":["../../../../../../src/ai-service/skills/system/superblocks-api/references/sql-databases.generated.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,g2ZAwZnB,CAAC"}