@tscircuit/fake-snippets 0.0.109 → 0.0.111

package/dist/index.js

@@ -65,7 +65,9 @@ var shippingInfoSchema = z.object({
 var accountSchema = z.object({
   account_id: z.string(),
   github_username: z.string(),
-  shippingInfo: shippingInfoSchema.optional()
+  shippingInfo: shippingInfoSchema.optional(),
+  personal_org_id: z.string().optional(),
+  is_tscircuit_staff: z.boolean().default(false)
 });
 var orderSchema = z.object({
   order_id: z.string(),
@@ -203,6 +205,15 @@ var packageReleaseSchema = z.object({
   circuit_json_build_completed_at: z.string().datetime().nullable().optional(),
   circuit_json_build_logs: z.array(z.any()).default([]),
   circuit_json_build_is_stale: z.boolean().default(false),
+  // Image Generation Process
+  image_generation_display_status: z.enum(["pending", "building", "complete", "error"]).default("pending"),
+  image_generation_in_progress: z.boolean().default(false),
+  image_generation_started_at: z.string().datetime().nullable().optional(),
+  image_generation_completed_at: z.string().datetime().nullable().optional(),
+  image_generation_logs: z.array(z.any()).nullable().default(null),
+  image_generation_is_stale: z.boolean().default(false),
+  image_generation_error: z.string().nullable().optional(),
+  image_generation_error_last_updated_at: z.string().datetime().nullable().optional(),
   // AI Review
   ai_review_text: z.string().nullable().default(null).optional(),
   ai_review_started_at: z.string().datetime().nullable().optional(),
@@ -311,6 +322,11 @@ var packageBuildSchema = z.object({
   circuit_json_build_completed_at: z.string().datetime().nullable().optional(),
   circuit_json_build_logs: z.array(z.any()).default([]),
   circuit_json_build_error: z.string().nullable().optional(),
+  image_generation_in_progress: z.boolean().default(false),
+  image_generation_started_at: z.string().datetime().nullable().optional(),
+  image_generation_completed_at: z.string().datetime().nullable().optional(),
+  image_generation_logs: z.array(z.any()).default([]),
+  image_generation_error: z.string().nullable().optional(),
   build_in_progress: z.boolean().default(false),
   build_started_at: z.string().datetime().nullable().optional(),
   build_completed_at: z.string().datetime().nullable().optional(),
@@ -319,6 +335,38 @@ var packageBuildSchema = z.object({
   preview_url: z.string().nullable().optional(),
   build_logs: z.string().nullable().optional()
 });
+var orgSchema = z.object({
+  org_id: z.string(),
+  github_handle: z.string().optional(),
+  owner_account_id: z.string(),
+  is_personal_org: z.boolean().default(false),
+  created_at: z.string().datetime(),
+  org_display_name: z.string().optional(),
+  org_name: z.string()
+});
+var orgAccountSchema = z.object({
+  org_account_id: z.string(),
+  org_id: z.string(),
+  account_id: z.string(),
+  is_owner: z.boolean().default(false),
+  created_at: z.string().datetime()
+});
+var publicOrgSchema = z.object({
+  org_id: z.string(),
+  //.uuid(),
+  owner_account_id: z.string(),
+  //.uuid(),
+  name: z.string().nullable(),
+  member_count: z.number(),
+  is_personal_org: z.boolean(),
+  display_name: z.string().optional(),
+  package_count: z.number(),
+  created_at: z.string(),
+  user_permissions: z.object({
+    can_manage_org: z.boolean().optional(),
+    can_manage_package: z.boolean().optional()
+  }).optional()
+});
 var databaseSchema = z.object({
   idCounter: z.number().default(0),
   snippets: z.array(snippetSchema).default([]),
@@ -329,6 +377,8 @@ var databaseSchema = z.object({
   accounts: z.array(accountSchema).default([]),
   packages: z.array(packageSchema).default([]),
   orders: z.array(orderSchema).default([]),
+  organizations: z.array(orgSchema).default([]),
+  orgAccounts: z.array(orgAccountSchema).default([]),
   orderFiles: z.array(orderFileSchema).default([]),
   accountSnippets: z.array(accountSnippetSchema).default([]),
   accountPackages: z.array(accountPackageSchema).default([]),
@@ -354,7 +404,7 @@ var extractTsciDependencies = (code) => {
   }));
 };
 var registryApi = axios.create({
-  baseURL: "https://registry-api.tscircuit.com",
+  baseURL: "https://api.tscircuit.com",
   headers: {
     Accept: "application/json",
     "Content-Type": "application/json"
@@ -362,7 +412,7 @@ var registryApi = axios.create({
 });
 var fetchPackageFromRegistry = async (owner, name) => {
   const fullName = `${owner}/${name}`;
-  console.log(`Fetching package ${fullName}...`);
+  console.log(`[autoload-dev-pkgs] \u{1F4E6} Fetching package ${fullName}...`);
   let packageData;
   try {
     const response = await registryApi.post("/packages/get", {
@@ -381,32 +431,39 @@ var fetchPackageFromRegistry = async (owner, name) => {
     });
     releaseData = response.data;
   } catch (e) {
-    console.error(`Failed to fetch release data for ${fullName}:`, e);
+    console.error(
+      `[autoload-dev-pkgs] \u274C Failed to fetch release data for ${fullName}:`,
+      e
+    );
     throw e;
   }
   let filesData;
   try {
-    const response = await registryApi.post("/package_files/list", {
-      package_release_id: releaseData.package_release.package_release_id
-    });
+    const response = await registryApi.post(
+      `package_files/list?package_release_id=${releaseData.package_release.package_release_id}`,
+      {}
+    );
     filesData = response.data;
     for (const file of filesData.package_files) {
       try {
-        const fileResponse = await registryApi.post("/package_files/get", {
-          package_release_id: releaseData.package_release.package_release_id,
-          file_path: file.file_path
-        });
+        const fileResponse = await registryApi.post(
+          `/package_files/get?package_file_id=${file.package_file_id}`,
+          {}
+        );
         file.content_text = fileResponse.data.package_file.content_text;
       } catch (e) {
         console.error(
-          `Failed to fetch content for file ${file.file_path} in package ${fullName}:`,
+          `[autoload-dev-pkgs] \u274C Failed to fetch content for file ${file.file_path} in package ${fullName}:`,
           e
         );
         throw e;
       }
     }
   } catch (e) {
-    console.error(`Failed to fetch files data for ${fullName}:`, e);
+    console.error(
+      `[autoload-dev-pkgs] \u274C Failed to fetch files data for ${fullName}:`,
+      e
+    );
     throw e;
   }
   return {
@@ -424,12 +481,12 @@ var loadPackageWithDependencies = async (db, owner, name, loadedPackages = /* @_
   try {
     result = await fetchPackageFromRegistry(owner, name);
   } catch (e) {
-    console.error(`\u2717 Failed to load ${packageKey}`);
+    console.error(`[autoload-dev-pkgs] \u274C Failed to load ${packageKey}`);
     return false;
   }
   const { package: pkg, release, files } = result;
   if (db.getPackageById(pkg.package_id)) {
-    console.log(`\u2713 Package ${packageKey} already exists`);
+    console.log(`[autoload-dev-pkgs] \u26A1 Package ${packageKey} already exists`);
     return true;
   }
   db.addPackage({
@@ -453,7 +510,7 @@ var loadPackageWithDependencies = async (db, owner, name, loadedPackages = /* @_
     });
   }
   loadedPackages.add(packageKey);
-  console.log(`\u2713 Loaded ${packageKey}`);
+  console.log(`[autoload-dev-pkgs] \u{1F4E6} Loaded ${packageKey}`);
   const mainFile = files.find(
     (f) => f.file_path === "index.tsx" || f.file_path === "index.ts"
   );
@@ -472,7 +529,7 @@ var loadPackageWithDependencies = async (db, owner, name, loadedPackages = /* @_
     if (!depLoaded) {
       allDepsLoaded = false;
       console.warn(
-        `\u26A0\uFE0F Failed to load dependency ${dep.owner}/${dep.name} for ${packageKey}`
+        `[autoload-dev-pkgs] \u26A0\uFE0F Failed to load dependency ${dep.owner}/${dep.name} for ${packageKey}`
       );
     }
   }
@@ -485,7 +542,7 @@ var loadAutoloadPackages = async (db) => {
     "autoload-packages.json"
   );
   if (!fs.existsSync(autoloadPath)) {
-    console.error("No autoload-packages.json found");
+    console.error("[autoload-dev-pkgs] \u274C No autoload-packages.json found");
     return;
   }
   const autoloadContent = JSON.parse(fs.readFileSync(autoloadPath, "utf8"));
@@ -506,10 +563,14 @@ var loadAutoloadPackages = async (db) => {
     }
   }
   console.log(`
-Package loading complete:`);
-  console.log(`\u2713 Successfully loaded: ${successCount} packages`);
+[autoload-dev-pkgs] \u{1F4CB} Package loading complete:`);
+  console.log(
+    `[autoload-dev-pkgs] \u2705 Successfully loaded: ${successCount} packages`
+  );
   if (failureCount > 0) {
-    console.log(`\u2717 Failed to load: ${failureCount} packages`);
+    console.log(
+      `[autoload-dev-pkgs] \u274C Failed to load: ${failureCount} packages`
+    );
   }
 };
 
@@ -2215,6 +2276,97 @@ export const SquareWaveModule = () => (
     started_at: null,
     completed_at: null
   });
+  const testOrg = db.addOrganization({
+    name: "test-organization",
+    owner_account_id: account_id
+  });
+  db.addOrganizationAccount({
+    org_id: testOrg.org_id,
+    account_id,
+    is_owner: true
+  });
+  const { package_release_id: orgPackageReleaseId } = db.addSnippet({
+    name: "test-organization/test-package",
+    unscoped_name: "test-package",
+    owner_name: "test-organization",
+    code: `
+export const TestComponent = ({ name }: { name: string }) => (
+  <resistor name={name} resistance="10k" />
+)
+`.trim(),
+    dts: `
+declare module "@tsci/test-organization.test-package" {
+  export const TestComponent: ({ name }: {
+    name: string;
+  }) => any;
+}
+`.trim(),
+    compiled_js: `
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestComponent = void 0;
+const TestComponent = ({
+  name
+}) => /*#__PURE__*/React.createElement("resistor", {
+  name: name,
+  resistance: "10k"
+});
+exports.TestComponent = TestComponent;
+    `.trim(),
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    snippet_type: "package",
+    description: "Test package for organization",
+    circuit_json: [
+      {
+        type: "source_component",
+        source_component_id: "source_component_0",
+        ftype: "simple_resistor",
+        name: "R1",
+        resistance: "10k"
+      }
+    ]
+  });
+  const orgPackageBuild = db.addPackageBuild({
+    package_release_id: orgPackageReleaseId,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    transpilation_in_progress: false,
+    transpilation_started_at: new Date(Date.now() - 5e3).toISOString(),
+    transpilation_completed_at: new Date(Date.now() - 3e3).toISOString(),
+    transpilation_logs: [
+      "[INFO] Starting transpilation...",
+      "[SUCCESS] Transpilation completed successfully"
+    ],
+    transpilation_error: null,
+    circuit_json_build_in_progress: false,
+    circuit_json_build_started_at: new Date(Date.now() - 3e3).toISOString(),
+    circuit_json_build_completed_at: new Date(Date.now() - 1e3).toISOString(),
+    circuit_json_build_logs: [
+      "[INFO] Starting circuit JSON build...",
+      "[SUCCESS] Circuit JSON build completed"
+    ],
+    circuit_json_build_error: null,
+    build_in_progress: false,
+    build_started_at: new Date(Date.now() - 1e4).toISOString(),
+    build_completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    build_error: null,
+    build_error_last_updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    preview_url: "http://localhost:3000/preview/org_package_build",
+    build_logs: "Build completed successfully"
+  });
+  const orgRelease = db.getPackageReleaseById(orgPackageReleaseId);
+  db.updatePackageRelease({
+    ...orgRelease,
+    latest_package_build_id: orgPackageBuild.package_build_id
+  });
+  db.addOrganization({
+    name: "testuser",
+    owner_account_id: account_id,
+    is_personal_org: true
+  });
 };
 
 // fake-snippets-api/lib/package_file/generate-fs-sha.ts
@@ -2353,7 +2505,8 @@ var initializer = combine(databaseSchema.parse({}), (set, get) => ({
   addAccount: (account) => {
     const newAccount = {
       account_id: account.account_id || `account_${get().idCounter + 1}`,
-      ...account
+      ...account,
+      is_tscircuit_staff: Boolean(account.is_tscircuit_staff)
     };
     set((state) => {
       return {
@@ -3357,10 +3510,10 @@ var initializer = combine(databaseSchema.parse({}), (set, get) => ({
     return updated;
   },
   addPackageBuild: (packageBuild) => {
-    const newPackageBuild = {
+    const newPackageBuild = packageBuildSchema.parse({
       package_build_id: crypto.randomUUID(),
       ...packageBuild
-    };
+    });
     set((state) => ({
       packageBuilds: [...state.packageBuilds, newPackageBuild],
       // Automatically update the package release to reference this as the latest build
@@ -3398,6 +3551,157 @@ var initializer = combine(databaseSchema.parse({}), (set, get) => ({
       return { ...state, packageBuilds };
     });
     return updated;
+  },
+  addOrganization: (organization) => {
+    const newOrganization = {
+      org_name: organization.name,
+      org_id: organization.org_id || `org_${get().idCounter + 1}`,
+      github_handle: organization.github_handle,
+      is_personal_org: organization.is_personal_org || false,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...organization
+    };
+    set((state) => ({
+      idCounter: state.idCounter + 1,
+      organizations: [...state.organizations, newOrganization],
+      // Add the creator as a member of the new org by setting their personal_org_id
+      accounts: state.accounts.map(
+        (account) => account.account_id === organization.owner_account_id ? { ...account, personal_org_id: newOrganization.org_id } : account
+      )
+    }));
+    return newOrganization;
+  },
+  getOrgs: (filters, auth) => {
+    let orgs = get().organizations;
+    if (filters?.owner_account_id) {
+      orgs = orgs.filter(
+        (org) => org.owner_account_id === filters.owner_account_id
+      );
+    }
+    if (filters?.github_handle) {
+      orgs = orgs.filter((org) => {
+        const account = get().accounts.find(
+          (account2) => account2.account_id === org.owner_account_id
+        );
+        return account?.github_username === filters.github_handle;
+      });
+    }
+    if (filters?.name) {
+      orgs = orgs.filter((org) => org.github_handle === filters.name);
+    }
+    return orgs.map((org) => {
+      const member_count = get().accounts.filter(
+        (account) => account.personal_org_id === org.org_id
+      ).length;
+      const package_count = get().packages.filter(
+        (pkg) => pkg.owner_org_id === org.org_id
+      ).length;
+      const can_manage_org = auth ? org.owner_account_id === auth.account_id : false;
+      return {
+        ...org,
+        member_count,
+        package_count,
+        can_manage_org
+      };
+    });
+  },
+  getOrg: (filters, auth) => {
+    let orgs = get().organizations;
+    if (filters?.org_id) {
+      orgs = orgs.filter((org2) => org2.org_id === filters.org_id);
+    }
+    if (filters?.org_name) {
+      orgs = orgs.filter((org2) => org2.org_name === filters.org_name);
+    }
+    if (filters?.github_handle) {
+      orgs = orgs.filter((org2) => org2.github_handle === filters.github_handle);
+    }
+    if (orgs.length === 0) {
+      return null;
+    }
+    const org = orgs[0];
+    const member_count = get().accounts.filter(
+      (account) => account.personal_org_id === org.org_id
+    ).length;
+    const package_count = get().packages.filter(
+      (pkg) => pkg.owner_org_id === org.org_id
+    ).length;
+    const can_manage_org = auth ? org.owner_account_id === auth.account_id : false;
+    return {
+      ...org,
+      member_count,
+      package_count,
+      can_manage_org
+    };
+  },
+  addOrganizationAccount: (organizationAccount) => {
+    const newOrgAccount = {
+      org_account_id: `org_account_${get().idCounter + 1}`,
+      org_id: organizationAccount.org_id,
+      account_id: organizationAccount.account_id,
+      is_owner: organizationAccount.is_owner || false,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    set((state) => ({
+      orgAccounts: [...state.orgAccounts, newOrgAccount],
+      idCounter: state.idCounter + 1
+    }));
+    return newOrgAccount;
+  },
+  getOrganizationAccount: (filters) => {
+    const state = get();
+    return state.orgAccounts.find((orgAccount) => {
+      if (filters.org_id && orgAccount.org_id !== filters.org_id) {
+        return false;
+      }
+      if (filters.account_id && orgAccount.account_id !== filters.account_id) {
+        return false;
+      }
+      return true;
+    });
+  },
+  getOrganizationAccounts: (filters) => {
+    const state = get();
+    return state.orgAccounts.filter((orgAccount) => {
+      if (filters?.org_id && orgAccount.org_id !== filters.org_id) {
+        return false;
+      }
+      if (filters?.account_id && orgAccount.account_id !== filters.account_id) {
+        return false;
+      }
+      return true;
+    });
+  },
+  removeOrganizationAccount: (filters) => {
+    let removed = false;
+    set((state) => {
+      const index = state.orgAccounts.findIndex(
+        (orgAccount) => orgAccount.org_id === filters.org_id && orgAccount.account_id === filters.account_id
+      );
+      if (index !== -1) {
+        state.orgAccounts.splice(index, 1);
+        removed = true;
+      }
+      return state;
+    });
+    return removed;
+  },
+  updateOrganization: (orgId, updates) => {
+    let updatedOrg;
+    set((state) => {
+      const orgIndex = state.organizations.findIndex(
+        (org) => org.org_id === orgId
+      );
+      if (orgIndex === -1) return state;
+      const updatedOrganizations = [...state.organizations];
+      updatedOrganizations[orgIndex] = {
+        ...updatedOrganizations[orgIndex],
+        ...updates
+      };
+      updatedOrg = updatedOrganizations[orgIndex];
+      return { ...state, organizations: updatedOrganizations };
+    });
+    return updatedOrg;
   }
 }));