@superblocksteam/vite-plugin-file-sync 2.0.3-next.100

package/dist/ai-service/integrations/to-sdk-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-sdk-prompt.d.ts","sourceRoot":"","sources":["../../../src/ai-service/integrations/to-sdk-prompt.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,YAAY,CAAC;AAErE,eAAO,MAAM,8BAA8B,GACzC,cAAc,cAAc,EAAE,KAC7B,MAAM,EAkBR,CAAC"}

package/dist/ai-service/integrations/to-sdk-prompt.js

@@ -0,0 +1,47 @@
+import { datasourceSdkClassByType, openApiIntegrationTypes } from "./const.js";
+export const integrationsToSdkPromptContent = (integrations) => {
+    const integrationsBySdkClassName = integrations.reduce((acc, integration) => {
+        const sdkClassName = getSdkClassName(integration.type);
+        if (!sdkClassName) {
+            return acc;
+        }
+        acc[sdkClassName] = [...(acc[sdkClassName] ?? []), integration];
+        return acc;
+    }, {});
+    return Object.entries(integrationsBySdkClassName).map(([sdkClassName, integrations]) => {
+        return formatSdkClassContent(sdkClassName, integrations);
+    });
+};
+const formatSdkClassContent = (sdkClassName, integrations) => {
+    const metadataById = integrations.reduce((acc, integration) => {
+        acc[integration.id] = {
+            name: integration.name,
+            ...(integration.metadata ?? {}),
+        };
+        return acc;
+    }, {});
+    return `class ${sdkClassName} extends Block {
+    static integrations: Integrations = ${JSON.stringify(metadataById, null, 2)};
+    
+    /**
+     * @param {string} name        The name of the block.
+     * @param {string} integration The name of the integration.
+     * @param {object} config      The config object.
+     * @returns {void}
+     */
+    constructor(name: string, integration: Integration, config: {
+        statement: Binding<string>
+    }) { /* ... */ }
+  }`;
+};
+const getSdkClassName = (integrationType) => {
+    let effectiveType = integrationType;
+    if (openApiIntegrationTypes.includes(effectiveType)) {
+        effectiveType = "restapiintegration";
+    }
+    if (effectiveType in datasourceSdkClassByType) {
+        return datasourceSdkClassByType[effectiveType];
+    }
+    return null;
+};
+//# sourceMappingURL=to-sdk-prompt.js.map

package/dist/ai-service/integrations/to-sdk-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-sdk-prompt.js","sourceRoot":"","sources":["../../../src/ai-service/integrations/to-sdk-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAG/E,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAC5C,YAA8B,EACpB,EAAE;IACZ,MAAM,0BAA0B,GAAG,YAAY,CAAC,MAAM,CACpD,CAAC,GAAG,EAAE,WAAW,EAAE,EAAE;QACnB,MAAM,YAAY,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,GAAG,CAAC;QACb,CAAC;QACD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;QAChE,OAAO,GAAG,CAAC;IACb,CAAC,EACD,EAAsC,CACvC,CAAC;IAEF,OAAO,MAAM,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC,GAAG,CACnD,CAAC,CAAC,YAAY,EAAE,YAAY,CAAC,EAAE,EAAE;QAC/B,OAAO,qBAAqB,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IAC3D,CAAC,CACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,qBAAqB,GAAG,CAC5B,YAAoB,EACpB,YAA8B,EAC9B,EAAE;IACF,MAAM,YAAY,GAAG,YAAY,CAAC,MAAM,CACtC,CAAC,GAAG,EAAE,WAAW,EAAE,EAAE;QACnB,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,GAAG;YACpB,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,GAAG,CAAC,WAAW,CAAC,QAAQ,IAAI,EAAE,CAAC;SAChC,CAAC;QACF,OAAO,GAAG,CAAC;IACb,CAAC,EACD,EAAyB,CAC1B,CAAC;IAEF,OAAO,SAAS,YAAY;0CACY,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;;;;;;;IAW3E,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CACtB,eAAuB,EACI,EAAE;IAC7B,IAAI,aAAa,GAAG,eAAe,CAAC;IACpC,IAAI,uBAAuB,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QACpD,aAAa,GAAG,oBAAoB,CAAC;IACvC,CAAC;IAED,IAAI,aAAa,IAAI,wBAAwB,EAAE,CAAC;QAC9C,OAAO,wBAAwB,CAC7B,aAAsD,CACvD,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}

package/dist/ai-service/integrations/types.d.ts

@@ -0,0 +1,31 @@
+import type { databaseIntegrationTypes, datasourceSdkClassByType } from "./const.js";
+export interface SdkIntegrationColumn {
+    name: string;
+    type: string;
+    [key: string]: any;
+}
+export interface SdkIntegrationTable {
+    type: string;
+    name: string;
+    schema: string;
+    columns: SdkIntegrationColumn[];
+    [key: string]: any;
+}
+export type SdkIntegrationType = keyof typeof datasourceSdkClassByType;
+export type DatabaseSdkIntegrationType = (typeof databaseIntegrationTypes)[number];
+export interface SdkIntegration {
+    name: string;
+    id: string;
+    type: SdkIntegrationType;
+    metadata: Record<string, any>;
+}
+export interface DatabaseSdkIntegration extends SdkIntegration {
+    type: DatabaseSdkIntegrationType;
+    metadata: {
+        schema: {
+            tables: SdkIntegrationTable[];
+        };
+    };
+}
+export type DatasourceSdkClass = (typeof datasourceSdkClassByType)[SdkIntegrationType];
+//# sourceMappingURL=types.d.ts.map

package/dist/ai-service/integrations/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ai-service/integrations/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,wBAAwB,CAAC;AAEvE,MAAM,MAAM,0BAA0B,GACpC,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,cAAc;IAC5D,IAAI,EAAE,0BAA0B,CAAC;IACjC,QAAQ,EAAE;QACR,MAAM,EAAE;YACN,MAAM,EAAE,mBAAmB,EAAE,CAAC;SAC/B,CAAC;KACH,CAAC;CACH;AAED,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,wBAAwB,CAAC,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/ai-service/integrations/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/ai-service/integrations/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/ai-service/integrations/types.ts"],"names":[],"mappings":""}

package/dist/ai-service/prompts/draft-subprompts/superblocks-api-draft.d.ts

@@ -0,0 +1,2 @@
+export declare const superblocksApiPrompt = "\n#### Example of creating and then registering a Superblocks API:\n\nCreating the API by adding the myApi.ts file:\n\n```ts\n// Path to this api: /pages/Page1/apis/myApi.ts\n\nimport {\n  Conditional,\n  Condition,\n  PostgreSQL,\n  JavaScript,\n  Api,\n} from \"@superblocksteam/library\";\n\nexport default new Api(\"myApi\", [\n  new Conditional(\"my_conditional\", {\n    if: Condition(true, [\n      new PostgreSQL(\"retrieve_orders\", \"integration_goes_here\", {\n        statement: \"SELECT * FROM orders\",\n      }),\n    ]),\n    else: [\n      new JavaScript(\"fallthrough\", () => \"we did not execute the sql query\"),\n    ],\n  }),\n]);\n```\n\nThen registering the myApi API inside the registerPage call, and executing it when an SbButton is clicked:\n\n```tsx\n// /pages/Page1/index.tsx\n\nimport { SbPage, SbApi, SbTable } from \"@superblocksteam/library\";\nimport { registerPage, showAlert } from \"@superblocksteam/library\";\n\nimport MyExampleAPI from \"./apis/example\";\n\nconst Page1 = () => (\n  <SbPage>\n    <SbButton\n      // APIs can be invoked with the SBEventFlow API.\n      onClick={SbEventFlow.runApis([\"myApi\"])}\n    />\n    <SbTable\n      // APIs are part of the state object just like components\n      tableData={(state) => state.myApi.response}\n    />\n  </SbPage>\n);\n\nexport default registerPage(\n  Page1,\n  {\n    name: \"MyPage\",\n    // You register APIs just like you would SbVariables\n    myApi: SbApi(MyExampleAPI),\n  },\n);\n```\n\n#### The Superblocks API TypeScript Type\n\nBelow is the full TypeScript spec for the APIs you create:\n\n```ts\n// @superblocksteam/types\n\nexport type JsonValue = undefined | null | number | string | boolean | JsonValue[] | object;\n\nclass Block {\n    constructor(name: string) {}\n    public run(): { output: JsonValue } { /* ... */ }\n}\n\ntype State = Record<string, JsonValue>\n\nclass JavaScript extends Block {\n    constructor(name: string, config: { fn: ({ /* ... */ }) => JsonValue }) { /* ... */ }\n}\n\ntype Integration = string\ntype Integrations = Record<Integration, JsonValue>;\n\nclass PostgreSQL extends Block {\n    static integrations: Integrations = {\n        \"eacaad74-192a-4a55-bbfd-3bdd3a6dfd53\": {\n            \"schema\": {\n                \"tables\": [\n                    {\n                        \"type\": \"TABLE\",\n                        \"name\": \"orders\",\n                        \"columns\": [\n                            {\n                                \"name\": \"id\",\n                                \"type\": \"int4\",\n                            },\n                            {\n                                \"name\": \"user_id\",\n                                \"type\": \"int8\",\n                            },\n                            {\n                                \"name\": \"product\",\n                                \"type\": \"varchar\",\n                            },\n                            {\n                                \"name\": \"date_purchased\",\n                                \"type\": \"date\",\n                            },\n                            {\n                                \"name\": \"user_email\",\n                                \"type\": \"varchar\",\n                            },\n                            {\n                                \"name\": \"price\",\n                                \"type\": \"float8\",\n                            },\n                        ],\n                        \"schema\": \"public\",\n                    }\n                ],\n            }\n        }\n    }\n\n    /**\n     * @param {string} name        The name of the block.\n     * @param {string} integration The name of the integration.\n     * @param {object} config      The config object.\n     * @returns {void}\n     */\n    constructor(name: string, integration: Integration, config: {\n        statement: string\n    }) { super(name) }\n}\n\nclass RestApi extends Block {\n  constructor(\n    name: string,\n    config: {\n      method: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" | \"PATCH\" | \"OPTIONS\" | \"HEAD\" | \"TRACE\" | \"CONNECT\";\n      url: string | (({ /* ... */ }) => string);\n    },\n  ) { super(name) }\n}\n\nclass Email extends Block {\n    constructor(name: string, config: {\n        from: string\n        to: string\n        subject: string\n        cc?: string[]\n        bcc?: string[]\n        body?: string | JsonValue | (({ /* ... */ }) => string | JsonValue)\n    }) { super(name) }\n}\n\nexport type Condition = {\n  when: boolean | ((state: State) => boolean);\n  then: Block[];\n};\n\nexport type Conditions = {\n  if: Condition;\n  elif?: Condition[];\n  else?: Block[];\n};\n\nclass Conditional extends Block {\n    constructor(name: string, config: Conditions) { super(name) }\n}\n\nclass TryCatch extends Block {\n    constructor(name: string, config: { try: Block[]; catch: Block[]; finally?: Block[] }) { super(name) }\n}\n\n/**\n * A Superblocks variable has the following access pattern:\n *\n * How to retrieve the value of a variable:\n * ```ts\n * CORRECT\n * my_variable.value\n *\n * // INCORRECT\n * my_variable\n * ```\n *\n * How to set the value of a variable:\n * ```ts\n * CORRECT\n * my_variable.set(value)\n *\n * // INCORRECT\n * my_variable = value\n * ```\n */\nclass Variables extends Block {\n    constructor(name: string, variables: {\n        // The key is the name of the variable.\n        // The value is the value of the variable.\n        [key: string]: JsonValue | (({ /* ... */ }) => JsonValue)\n    }) { super(name) }\n}\n\nclass Loop extends Block {\n    constructor(\n        name: string,\n        // You can either loop over a certain number or times, over an array, or forever until the condition is false.\n        over: number | (({ /* ... */ }) => number) | JsonValue[] | (({ /* ... */ }) => JsonValue[]) | boolean | (({ /* ... */ }) => boolean),\n        variables: {\n            // What the variable name for the current item is.\n            item: string,\n            // What the variable name for the current index is.\n            index: number,\n        },\n        blocks: Block[]\n    ) { super(name) }\n}\n\nclass Parallel extends Block {\n    constructor(\n        name: string,\n        over: JsonValue[] | (({ /* ... */ }) => JsonValue[]),\n        variables: {\n            // What the variable name for the current item is.\n            item: string,\n        },\n        blocks: Block[],\n    ) { super(name) }\n}\n\nclass Api {\n    constructor(name: string, steps: Block[]) {}\n    public get response(): JsonValue { /* ... */ }\n    public get error(): string | undefined { /* ... */ }\n    public run(): void { /* ... */ }\n    public cancel(): void { /* ... */ }\n}\n```\n\n#### Example Usage\n\nBelow are examples of how you create Superblocks APIs, along with annotations to describe different pieces of functinality and expectations.\n\n##### Example 1: Simple API with conditional\n\n```ts\n// Path to this api would be: /pages/Page1/apis/getOrders.ts\n\nimport {\n  Conditional,\n  Condition,\n  PostgreSQL,\n  JavaScript,\n  Api,\n} from \"@superblocksteam/library\";\n\nexport default new Api(\n    \"getOrders\",\n    [\n        new Conditional(\"my_conditional\", {\n            if: {\n                when: true,\n                then: [\n                    new PostgreSQL(\"retrieve_orders\", \"integration_goes_here\", {\n                        statement: 'SELECT * FROM orders'\n                    })\n                ]\n            },\n            else: [\n                new JavaScript(\"fallthrough\", { fn: () => \"we did not execute the sql query\" })\n            ]\n        })\n    ]\n)\n```\n\nTo run register and run the API we defined above:\n\n```tsx\n// /pages/Page1/index.tsx\n\nimport { SbPage, SbApi, SbTable, SbButton } from \"@superblocksteam/library\";\nimport { registerPage, showAlert } from \"@superblocksteam/library\";\n\nimport getOrders from \"./apis/getOrders\";\n\nconst Page1 = () => (\n  <SbPage>\n    <SbButton\n      // APIs can be invoked with the SBEventFlow API.\n      onClick={SbEventFlow.runApis([\"getOrders\"])}\n    />\n    // ...\n    <SbTable>\n      // APIs are part of the state object just like components. tableData=\n      {(state) => state.getOrders.response}\n    </SbTable>\n  </SbPage>\n);\n\nexport default registerPage(\n  Page1,\n  {\n    name: \"MyPage\",\n    // You register APIs just like you would SbVariables.\n    getOrders: SbApi(getOrders),\n  },\n);\n```\n\n##### Example 2: API where steps reference outputs of previous steps\n\nThink hard about how you access the output of previous steps. You MUST use the output property of the previous step variable. There is no other way to access the output of a previous step (other than using a Variable block, but that is not what you want in this case and should only be used in very specific cases).\n\n```ts\n// Path to this api would be: /pages/Page1/apis/getOrders.ts\n\nimport {\n  PostgreSQL,\n  JavaScript,\n  Api,\n} from \"@superblocksteam/library\";\n\nexport default new Api(\n    \"getOrders\",\n    [\n        new PostgreSQL(\"retrieve_orders\", \"integration_goes_here\", {\n            statement: 'SELECT * FROM orders'\n        }),\n        new JavaScript(\"format_orders\", ({ retrieve_orders }) => {\n            // Format the orders data with dates\n            // we access the output of the retrieve_orders block using the output property of the retrieve_orders variable\n            return retrieve_orders.output.map(order => ({\n                ...order,\n                date: new Date(order.date).toLocaleDateString()\n            }));\n        })\n    ]\n)\n```\n\nThen you would register the api as normal in the page file inside the registerPage function call, same as the first example.\n\n#### Control Flow blocks\n\nThe API blocks that are considered \"Control Flow\" blocks are:\n\n- Conditional\n- Loop\n- TryCatch\n- Parallel\n\n#### Rules for using Superblocks APIs\n\nThink hard about the following important rules for correctly using Superblocks APIs:\n\n- You must use a deconstructed state object as the function parameter for dynamic block fields. The valid keys are (1) Superblocks entities (components, variables, etc) and (2) previous block outputs that are in the lexial scope. Example below:\n\n```ts\n// CORRECT: uses deconstructed state\n({ Dropdown1, TextInput1 }) => Dropdown1.selectedOptionsValue + TextInput1.value\n\n// INCORRECT: uses state object directly\n(state) => state.Dropdown1.selectedOptionsValue + state.TextInput1.value\n```\n\n- APIs have lexical scope. For example, blocks in the if-statement of a conditional block will not have access to the state of the else-block.\n\n- Block outputs are immutable. Do not mutate the output of a block.\n\n- The output for a control flow block is the output of the last child block inside of that control flow block.\n\n- Favor the defined control flow blocks (conditional, loop, try-catch) over using the JavaScript block to try and control the flow of your API. This allows you to use Superblocks integrations more easily and allows the user to more easily maintain the API.\n\n- Backend APIs CANNOT mutate frontend state inside of the API.\n\n- You will not always be told which integrations to use in your API; you will have to determine that yourself based on the data you need to fetch.\n\n- Never add comments to code you generate.\n";
+//# sourceMappingURL=superblocks-api-draft.d.ts.map

package/dist/ai-service/prompts/draft-subprompts/superblocks-api-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superblocks-api-draft.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/prompts/draft-subprompts/superblocks-api-draft.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,0vWA+XhC,CAAC"}

package/dist/ai-service/prompts/draft-subprompts/superblocks-api-draft.js

@@ -0,0 +1,386 @@
+// This includes some content for other types of blocks that are not yet supported: basically anything other than JS blocks
+export const superblocksApiPrompt = /*md*/ `
+#### Example of creating and then registering a Superblocks API:
+
+Creating the API by adding the myApi.ts file:
+
+\`\`\`ts
+// Path to this api: /pages/Page1/apis/myApi.ts
+
+import {
+  Conditional,
+  Condition,
+  PostgreSQL,
+  JavaScript,
+  Api,
+} from "@superblocksteam/library";
+
+export default new Api("myApi", [
+  new Conditional("my_conditional", {
+    if: Condition(true, [
+      new PostgreSQL("retrieve_orders", "integration_goes_here", {
+        statement: "SELECT * FROM orders",
+      }),
+    ]),
+    else: [
+      new JavaScript("fallthrough", () => "we did not execute the sql query"),
+    ],
+  }),
+]);
+\`\`\`
+
+Then registering the myApi API inside the registerPage call, and executing it when an SbButton is clicked:
+
+\`\`\`tsx
+// /pages/Page1/index.tsx
+
+import { SbPage, SbApi, SbTable } from "@superblocksteam/library";
+import { registerPage, showAlert } from "@superblocksteam/library";
+
+import MyExampleAPI from "./apis/example";
+
+const Page1 = () => (
+  <SbPage>
+    <SbButton
+      // APIs can be invoked with the SBEventFlow API.
+      onClick={SbEventFlow.runApis(["myApi"])}
+    />
+    <SbTable
+      // APIs are part of the state object just like components
+      tableData={(state) => state.myApi.response}
+    />
+  </SbPage>
+);
+
+export default registerPage(
+  Page1,
+  {
+    name: "MyPage",
+    // You register APIs just like you would SbVariables
+    myApi: SbApi(MyExampleAPI),
+  },
+);
+\`\`\`
+
+#### The Superblocks API TypeScript Type
+
+Below is the full TypeScript spec for the APIs you create:
+
+\`\`\`ts
+// @superblocksteam/types
+
+export type JsonValue = undefined | null | number | string | boolean | JsonValue[] | object;
+
+class Block {
+    constructor(name: string) {}
+    public run(): { output: JsonValue } { /* ... */ }
+}
+
+type State = Record<string, JsonValue>
+
+class JavaScript extends Block {
+    constructor(name: string, config: { fn: ({ /* ... */ }) => JsonValue }) { /* ... */ }
+}
+
+type Integration = string
+type Integrations = Record<Integration, JsonValue>;
+
+class PostgreSQL extends Block {
+    static integrations: Integrations = {
+        "eacaad74-192a-4a55-bbfd-3bdd3a6dfd53": {
+            "schema": {
+                "tables": [
+                    {
+                        "type": "TABLE",
+                        "name": "orders",
+                        "columns": [
+                            {
+                                "name": "id",
+                                "type": "int4",
+                            },
+                            {
+                                "name": "user_id",
+                                "type": "int8",
+                            },
+                            {
+                                "name": "product",
+                                "type": "varchar",
+                            },
+                            {
+                                "name": "date_purchased",
+                                "type": "date",
+                            },
+                            {
+                                "name": "user_email",
+                                "type": "varchar",
+                            },
+                            {
+                                "name": "price",
+                                "type": "float8",
+                            },
+                        ],
+                        "schema": "public",
+                    }
+                ],
+            }
+        }
+    }
+
+    /**
+     * @param {string} name        The name of the block.
+     * @param {string} integration The name of the integration.
+     * @param {object} config      The config object.
+     * @returns {void}
+     */
+    constructor(name: string, integration: Integration, config: {
+        statement: string
+    }) { super(name) }
+}
+
+class RestApi extends Block {
+  constructor(
+    name: string,
+    config: {
+      method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "TRACE" | "CONNECT";
+      url: string | (({ /* ... */ }) => string);
+    },
+  ) { super(name) }
+}
+
+class Email extends Block {
+    constructor(name: string, config: {
+        from: string
+        to: string
+        subject: string
+        cc?: string[]
+        bcc?: string[]
+        body?: string | JsonValue | (({ /* ... */ }) => string | JsonValue)
+    }) { super(name) }
+}
+
+export type Condition = {
+  when: boolean | ((state: State) => boolean);
+  then: Block[];
+};
+
+export type Conditions = {
+  if: Condition;
+  elif?: Condition[];
+  else?: Block[];
+};
+
+class Conditional extends Block {
+    constructor(name: string, config: Conditions) { super(name) }
+}
+
+class TryCatch extends Block {
+    constructor(name: string, config: { try: Block[]; catch: Block[]; finally?: Block[] }) { super(name) }
+}
+
+/**
+ * A Superblocks variable has the following access pattern:
+ *
+ * How to retrieve the value of a variable:
+ * \`\`\`ts
+ * CORRECT
+ * my_variable.value
+ *
+ * // INCORRECT
+ * my_variable
+ * \`\`\`
+ *
+ * How to set the value of a variable:
+ * \`\`\`ts
+ * CORRECT
+ * my_variable.set(value)
+ *
+ * // INCORRECT
+ * my_variable = value
+ * \`\`\`
+ */
+class Variables extends Block {
+    constructor(name: string, variables: {
+        // The key is the name of the variable.
+        // The value is the value of the variable.
+        [key: string]: JsonValue | (({ /* ... */ }) => JsonValue)
+    }) { super(name) }
+}
+
+class Loop extends Block {
+    constructor(
+        name: string,
+        // You can either loop over a certain number or times, over an array, or forever until the condition is false.
+        over: number | (({ /* ... */ }) => number) | JsonValue[] | (({ /* ... */ }) => JsonValue[]) | boolean | (({ /* ... */ }) => boolean),
+        variables: {
+            // What the variable name for the current item is.
+            item: string,
+            // What the variable name for the current index is.
+            index: number,
+        },
+        blocks: Block[]
+    ) { super(name) }
+}
+
+class Parallel extends Block {
+    constructor(
+        name: string,
+        over: JsonValue[] | (({ /* ... */ }) => JsonValue[]),
+        variables: {
+            // What the variable name for the current item is.
+            item: string,
+        },
+        blocks: Block[],
+    ) { super(name) }
+}
+
+class Api {
+    constructor(name: string, steps: Block[]) {}
+    public get response(): JsonValue { /* ... */ }
+    public get error(): string | undefined { /* ... */ }
+    public run(): void { /* ... */ }
+    public cancel(): void { /* ... */ }
+}
+\`\`\`
+
+#### Example Usage
+
+Below are examples of how you create Superblocks APIs, along with annotations to describe different pieces of functinality and expectations.
+
+##### Example 1: Simple API with conditional
+
+\`\`\`ts
+// Path to this api would be: /pages/Page1/apis/getOrders.ts
+
+import {
+  Conditional,
+  Condition,
+  PostgreSQL,
+  JavaScript,
+  Api,
+} from "@superblocksteam/library";
+
+export default new Api(
+    "getOrders",
+    [
+        new Conditional("my_conditional", {
+            if: {
+                when: true,
+                then: [
+                    new PostgreSQL("retrieve_orders", "integration_goes_here", {
+                        statement: 'SELECT * FROM orders'
+                    })
+                ]
+            },
+            else: [
+                new JavaScript("fallthrough", { fn: () => "we did not execute the sql query" })
+            ]
+        })
+    ]
+)
+\`\`\`
+
+To run register and run the API we defined above:
+
+\`\`\`tsx
+// /pages/Page1/index.tsx
+
+import { SbPage, SbApi, SbTable, SbButton } from "@superblocksteam/library";
+import { registerPage, showAlert } from "@superblocksteam/library";
+
+import getOrders from "./apis/getOrders";
+
+const Page1 = () => (
+  <SbPage>
+    <SbButton
+      // APIs can be invoked with the SBEventFlow API.
+      onClick={SbEventFlow.runApis(["getOrders"])}
+    />
+    // ...
+    <SbTable>
+      // APIs are part of the state object just like components. tableData=
+      {(state) => state.getOrders.response}
+    </SbTable>
+  </SbPage>
+);
+
+export default registerPage(
+  Page1,
+  {
+    name: "MyPage",
+    // You register APIs just like you would SbVariables.
+    getOrders: SbApi(getOrders),
+  },
+);
+\`\`\`
+
+##### Example 2: API where steps reference outputs of previous steps
+
+Think hard about how you access the output of previous steps. You MUST use the output property of the previous step variable. There is no other way to access the output of a previous step (other than using a Variable block, but that is not what you want in this case and should only be used in very specific cases).
+
+\`\`\`ts
+// Path to this api would be: /pages/Page1/apis/getOrders.ts
+
+import {
+  PostgreSQL,
+  JavaScript,
+  Api,
+} from "@superblocksteam/library";
+
+export default new Api(
+    "getOrders",
+    [
+        new PostgreSQL("retrieve_orders", "integration_goes_here", {
+            statement: 'SELECT * FROM orders'
+        }),
+        new JavaScript("format_orders", ({ retrieve_orders }) => {
+            // Format the orders data with dates
+            // we access the output of the retrieve_orders block using the output property of the retrieve_orders variable
+            return retrieve_orders.output.map(order => ({
+                ...order,
+                date: new Date(order.date).toLocaleDateString()
+            }));
+        })
+    ]
+)
+\`\`\`
+
+Then you would register the api as normal in the page file inside the registerPage function call, same as the first example.
+
+#### Control Flow blocks
+
+The API blocks that are considered "Control Flow" blocks are:
+
+- Conditional
+- Loop
+- TryCatch
+- Parallel
+
+#### Rules for using Superblocks APIs
+
+Think hard about the following important rules for correctly using Superblocks APIs:
+
+- You must use a deconstructed state object as the function parameter for dynamic block fields. The valid keys are (1) Superblocks entities (components, variables, etc) and (2) previous block outputs that are in the lexial scope. Example below:
+
+\`\`\`ts
+// CORRECT: uses deconstructed state
+({ Dropdown1, TextInput1 }) => Dropdown1.selectedOptionsValue + TextInput1.value
+
+// INCORRECT: uses state object directly
+(state) => state.Dropdown1.selectedOptionsValue + state.TextInput1.value
+\`\`\`
+
+- APIs have lexical scope. For example, blocks in the if-statement of a conditional block will not have access to the state of the else-block.
+
+- Block outputs are immutable. Do not mutate the output of a block.
+
+- The output for a control flow block is the output of the last child block inside of that control flow block.
+
+- Favor the defined control flow blocks (conditional, loop, try-catch) over using the JavaScript block to try and control the flow of your API. This allows you to use Superblocks integrations more easily and allows the user to more easily maintain the API.
+
+- Backend APIs CANNOT mutate frontend state inside of the API.
+
+- You will not always be told which integrations to use in your API; you will have to determine that yourself based on the data you need to fetch.
+
+- Never add comments to code you generate.
+`;
+//# sourceMappingURL=superblocks-api-draft.js.map

package/dist/ai-service/prompts/draft-subprompts/superblocks-api-draft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"superblocks-api-draft.js","sourceRoot":"","sources":["../../../../src/ai-service/prompts/draft-subprompts/superblocks-api-draft.ts"],"names":[],"mappings":"AAAA,2HAA2H;AAE3H,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+X1C,CAAC"}

package/dist/ai-service/prompts/draft-subprompts/superblocks-layouts-with-grid-examples.d.ts

@@ -0,0 +1,2 @@
+export declare const superblocksLayoutsPrompt = "\n### Layout and Sizing in Superblocks\n\nAll layouts in Superblocks are configured through the `SbContainer` component.  \n`SbContainer` provides both layout and optional visual styling.\n\n```jsx\n<SbContainer\n  variant=\"card\" | \"none\" // default is \"none\"\n  layout=\"vertical\" | \"horizontal\" | \"freeform\" // default is \"vertical\"\n>\n  {/* Children here */}\n</SbContainer>\n```\n\nWe have three main layout options in Superblocks:\n\n- Vertical Stack (`vertical`)\n- Horizontal Stack (`horizontal`)\n- Free form (`freeform`)\n\nFor new designs, we recommend using Stacks for most use cases.\n\nThe `variant` prop is optional and can be set to `\"card\"` or `\"none\"`. Default is `\"none\"`.\n`\"card\"` applies a card-like visual style to the container, such as rounded corners, white background, and padding.\n\n---\n\n### Height and Width Options\n\nAll Superblocks components support width and height. They take in a `Dim` object, which has 3 main options:\n\n- `Dim.fit()`: Fit to content size, this is the default behavior and can be omitted.\n- `Dim.px(100)`: Fixed pixel size.\n- `Dim.fill()` or `Dim.fill(2)`: Fill available space with an optional weight.\n\n> IMPORTANT: Prefer using `Dim.fit()` over `Dim.px()` for height and width unless you have a specific reason to use fixed pixel sizes. This is extra true for containers\n> IMPORTANT: Prefer using `Dim.fill()` or `Dim.fit()` over `Dim.px()` for width unless you have a specific reason to use fixed pixel sizes.\n\n**Examples**:\n\n```jsx\n<SbText name=\"Text1\" width={Dim.px(2)}>Hello</SbText>   // 2 pixels\n<SbText name=\"Text1\" width={Dim.fit()}>Hello</SbText>   // Fit to content (default)\n<SbText name=\"Text1\" width={Dim.fill()}>Hello</SbText>  // Fill available space, no weight (aka 1)\n<SbText name=\"Text1\" width={Dim.fill(2)}>Hello</SbText> // Fill available space, with weight of 2\n```\n\n---\n\n### 2. **Grid-Specific Width (Columns)**\n\nWhen using `layout=\"freeform\"`, width is based on columns.\n\n- `Dim.columns(10)` specifies the number of columns.\n- Note: `fill`, `fit`, and `px` are not supported for width in grid layouts.\n\n**Example**:\n\n```jsx\n<SbContainer layout=\"freeform\" columns={12}>\n  <SbText name=\"Text1\" width={Dim.columns(2)}>\n    Hello\n  </SbText>\n</SbContainer>\n```\n\n---\n\n### 3. **Height Options with Rows**\n\nWhen using `layout=\"freeform\"`, height can be configured with rows.\n\n- `Dim.rows(2)` specifies the number of rows.\n- `Dim.px(100)` specifies a fixed pixel size.\n- `Dim.fit()` fits to content size (default).\n- `Dim.fill()` is **not supported** for height inside grid layouts.\n\nYou can specify height using rows to override the default `\"fit\"` behavior, similar to pixel-based height.\n\n**Example**:\n\n```jsx\n<SbContainer layout=\"freeform\" columns={12}>\n  <SbText name=\"Text1\" height={Dim.rows(2)} width={Dim.columns(2)}>\n    Hello\n  </SbText>{' '}\n  // 2 rows in height, 2 columns in width\n</SbContainer>\n```\n\n---\n\n### 4. **Grid Layout Setup**\n\nA container with `layout=\"freeform\"` can be configured with columns and rows.  \nIndividual children inside the container can have margins, constraints, and dynamic sizing options.\n\n```\nSbContainer (layout=\"freeform\") -\n  columns: number\n  rows: \"auto\" | number // defaults to auto\n  row-size: Dim<px> // defaults to 12px\nGridChild (components inside the container) -\n  margin-top: Dim<row | px>\n  margin-left: Dim<column>\n  height: Dim<row | px | fit>\n  width: Dim<column>\n  constraintTop: GridChild | [GridChild]\n```\n\n---\n\n#### **Grid Example 1: Items Stacked with a Gap**\n\nTwo items stacked vertically, both full width, with a gap of 1.\n\n```\n[ Text1 ]\n[ Text2 ]\n```\n\n```jsx\n<SbContainer layout=\"freeform\" columns={3}>\n  <SbText name=\"Text1\" width={Dim.columns(3)}>\n    Hello\n  </SbText>\n  <SbText name=\"Text2\" constraintTop=\"Text1\" width={Dim.columns(3)}>\n    World\n  </SbText>\n</SbContainer>\n```\n\n---\n\n#### **Grid Example 2: Items Side by Side**\n\nThree items side by side, each taking part of the grid.\n\n```\n[ Text1 ][ Text2 ][ Text3 ]\n```\n\n```jsx\n<SbContainer layout=\"freeform\" columns={4}>\n  <SbText name=\"Text1\" width={Dim.columns(2)}>\n    Hello\n  </SbText>\n  <SbText name=\"Text2\" width={Dim.columns(2)} marginLeft={Dim.columns(2)}>\n    World\n  </SbText>\n  <SbText name=\"Text3\" width={Dim.columns(2)} marginLeft={Dim.columns(4)}>\n    World\n  </SbText>\n</SbContainer>\n```\n\n---\n\n#### **Grid Example 3: Staggered Items**\n\nA staggered layout using constraints and margins.\n\n```\n[ Text1 ]\n[ Text2 ][ Text3 ]\n```\n\n```jsx\n<SbContainer layout=\"freeform\" columns={2}>\n  <SbText name=\"Text1\" width={Dim.columns(1)}>\n    Hello\n  </SbText>\n  <SbText name=\"Text2\" width={Dim.columns(1)} constraintTop=\"Text1\">\n    World\n  </SbText>\n  <SbText name=\"Text3\" width={Dim.columns(1)} marginLeft={Dim.columns(1)} marginTop={Dim.rows(1)}>\n    World Again\n  </SbText>\n</SbContainer>\n```\n\nIn this example:\n\n- `Text2` is constrained to `Text1`.\n- `Text3` is **not constrained** to `Text2`, but uses a margin of 1 row and 1 column.\n- If `Text1` grows in size, `Text2` moves down, but `Text3` stays in place.\n\n#### **Grid Example 4: Key Value Pairs**\n\n[ Key 1 ][ Value 1 ]\n[ Key 2 ][ Value 2 ]\n\n```jsx\n<SbContainer layout=\"freeform\" columns={12}>\n  <SbText name=\"Key1\" width={Dim.columns(4)}>\n    Key 1\n  </SbText>\n  <SbText name=\"Value1\" width={Dim.columns(8)} marginLeft={Dim.columns(4)}>\n    Value 1\n  </SbText>\n  <SbText name=\"Key2\" width={Dim.columns(4)} constraintTop=\"Key1\">\n    Key 2\n  </SbText>\n  <SbText name=\"Value2\" width={Dim.columns(8)} marginLeft={Dim.columns(4)} constraintTop=\"Value1\">\n    Value 2\n  </SbText>\n</SbContainer>\n\nIMPORTANT: The `constraintTop` prop is used to specify the component that this component should be constrained to. You must use and supply names to all components that you want to reference in the `constraintTop` prop.\n```\n\n### Import Location\n\n```ts\nimport { Dim } from '@superblocksteam/library';\n```\n";
+//# sourceMappingURL=superblocks-layouts-with-grid-examples.d.ts.map

package/dist/ai-service/prompts/draft-subprompts/superblocks-layouts-with-grid-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superblocks-layouts-with-grid-examples.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/prompts/draft-subprompts/superblocks-layouts-with-grid-examples.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,k/LAyNpC,CAAC"}