@rxdrag/website-studio 0.0.4 → 0.0.5

package/dist/generator/classes/Coder.d.ts

@@ -8,6 +8,7 @@ export declare abstract class Coder {
     protected elements: INodeSchema<XData>[];
     protected imports: Record<string, string[]>;
     protected typeImports: Record<string, string[]>;
+    protected defaultImports: Record<string, string[]>;
     constructor(comsStore: TemplatesStore, elements: INodeSchema<XData>[]);
     getUsedMaterials(): IMaterial[];
     getMaterialsFromElements(elements: INodeSchema<XData>[], usedMaterials: IMaterial[]): void;
@@ -30,6 +31,7 @@ export declare abstract class Coder {
         [key: string]: INodeSchema | undefined;
     } | undefined, spaces?: number): string;
     addImport(componentName: string, packagePath: string): void;
+    addDefaultImport(componentName: string, packagePath: string): void;
     addTypeImport(componentName: string, packagePath: string): void;
     abstract getFileName(): string;
 }

package/dist/index.mjs

@@ -15857,122 +15857,91 @@ const tailwindCssTemplate = {
 };
 const slugTemplate = {
   name: "$slug.tsx",
-  content: `import type { LoaderFunction, MetaFunction } from "@remix-run/node";
-import { useLoaderData } from "@remix-run/react";
-import { EntifyClient } from "@rxdrag/entify-hooks";
-import { MediaFields, Post, PostCategoryFields, PostFields, ProductCategoryFields, ProductFields, Slug, SlugBoolExp, SlugDistinctExp, SlugEntityName, SlugFields, SlugOrderBy, UserFields } from "@rxdrag/rxcms-models";
-import { Datas } from "@rxdrag/website-components";
-import { PostPage } from "~/components/PostPage";
-import { ProductPage } from "~/components/ProductPage";
-
-export const meta: MetaFunction = ({ data }) => {
-  const datas = data as Datas | undefined
-  const obj = datas?.post || datas?.product;
-  return [
-    { title: obj?.seoTitle || obj?.title },
-    {
-      name: "description",
-      content: obj?.seoDescription
-    },
-  ];
-};
+  content: `import { redirect, type LoaderFunction, type LoaderFunctionArgs } from "~/deploy/remix-run-node";
+import type { WebsiteSettings, WebsiteSettingsBoolExp, WebsiteSettingsOrderBy, WebsiteSettingsDistinctExp, Product, ProductBoolExp, ProductDistinctExp, ProductOrderBy, Post, PostBoolExp, PostDistinctExp, PostOrderBy } from "@rxdrag/rxcms-models";
+import { WebsiteSettingsQueryOptions, WebsiteSettingsFields, ProductFields, ProductQueryOptions, PostQueryOptions } from "@rxdrag/rxcms-models";
+import { queryOneEntity } from "@rxdrag/model-remix-lib";
+import { getEnvVariables } from "~/deploy/get-env";
 
 // 定义 loader 函数
-export const loader: LoaderFunction = async ({ params }) => {
+export const loader: LoaderFunction = async (args: LoaderFunctionArgs) => {
+  const { params } = args
   const { slug } = params;
-  if (!process.env.VITE_SERVER_URL) {
-    return { status: 404, error: new Error("VITE_SERVER_URL Not Set") };
-  }
-  const websiteId = process.env.VITE_WEBSITE_ID;
-  if (!process.env.VITE_WEBSITE_ID) {
-    return { status: 404, error: new Error("VITE_WEBSITE_ID Not Set") };
-  }
 
-  const entifyClient = new EntifyClient(process.env.VITE_SERVER_URL);
-  const slugObj = await entifyClient.oneEntity<Slug, SlugBoolExp, SlugOrderBy, SlugDistinctExp>(SlugEntityName, {
-    queryArgs: {
-      where: {
-        [SlugFields.websiteId]: {
-          "_eq": websiteId
-        },
+  if (!slug) {
+    throw new Response(null, { status: 404 });
+  }
+  const envVariables = getEnvVariables(args)
 
+  const webisteSettings = await queryOneEntity<WebsiteSettings, WebsiteSettingsBoolExp, WebsiteSettingsOrderBy, WebsiteSettingsDistinctExp>(
+    new WebsiteSettingsQueryOptions(
+      [
+        WebsiteSettingsFields.id,
+        WebsiteSettingsFields.map301,
+      ],
+    ),
+    envVariables
+  )
+  if (webisteSettings?.map301) {
+    for (const line of webisteSettings.map301?.split('
+')) {
+      const [from, to] = line.split(',');
+      if (slug === from) {
+        return redirect(to, 301);
       }
-    },
-    fields: [
+    }
+  }
+
+  const product = await queryOneEntity<Product, ProductBoolExp, ProductOrderBy, ProductDistinctExp>(
+    new ProductQueryOptions(
+      [
+        ProductFields.id,
+        ProductFields.slug,
+      ],
       {
-        [SlugFields.post]: [
-          PostFields.id,
-          PostFields.title,
-          PostFields.seoTitle,
-          PostFields.seoKeywords,
-          PostFields.seoDescription,
-          PostFields.content,
-          {
-            [PostFields.author]: [
-              UserFields.id,
-              UserFields.name,
-              {
-                [UserFields.avatar]: [
-                  MediaFields.id,
-                  {
-                    [MediaFields.file]: [
-                      'thumbnail',
-                    ]
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            [PostFields.category]: [
-              PostCategoryFields.id,
-              PostCategoryFields.name,
-              PostCategoryFields.description
-            ]
-          }
-        ],
-        [SlugFields.product]: [
-          ProductFields.id,
-          ProductFields.title,
-          ProductFields.seoTitle,
-          ProductFields.seoKeywords,
-          ProductFields.seoDescription,
-          ProductFields.content,
-          {
-            [ProductFields.category]: [
-              ProductCategoryFields.id,
-              ProductCategoryFields.name,
-              ProductCategoryFields.description
-            ]
+        where: {
+          slug: {
+            _eq: slug
           }
-        ]
+        }
       }
-    ],
-  });
-  return {
-    datas: {
-      post: slugObj?.post,
-      product: slugObj?.product
-    }
-  };
-};
+    ),
+    envVariables
+  )
+  if (product) {
+    return redirect(\`/product/\${product.slug}\`, 301);
+  }
 
+  const post = await queryOneEntity<Post, PostBoolExp, PostOrderBy, PostDistinctExp>(
+    new PostQueryOptions(
+      [
+        ProductFields.id,
+        ProductFields.slug,
+      ],
+      {
+        where: {
+          slug: {
+            _eq: slug
+          }
+        }
+      }
+    ),
+    envVariables
+  )
 
-export default function SlugPage() {
-  const { datas } = useLoaderData<{ datas: Datas | undefined }>();
-  if (datas?.post) {
-    return <PostPage datas={datas as Datas} />
-  } else if (datas?.product) {
-    return <ProductPage datas={datas as Datas} />
+  if (post) {
+    return redirect(\`/post/\${post.slug}\`, 301);
   }
-  return <>404 can find slug</>
-}
+
+  return redirect("/404", 404);
+};
 `
 };
 class Coder {
   constructor(comsStore, elements) {
     __publicField(this, "imports", {});
     __publicField(this, "typeImports", {});
+    __publicField(this, "defaultImports", {});
     this.comsStore = comsStore;
     this.elements = elements;
     const customizedComponents = this.getCustomizedComponents();
@@ -16051,9 +16020,10 @@ class Coder {
     }
   }
   getImportsCode() {
+    const defaultImportsCode = Object.keys(this.defaultImports).map((key) => `import ${this.defaultImports[key].join(", ")} from "${key}"`).join("\n");
     const importsCode = Object.keys(this.imports).map((key) => `import { ${this.imports[key].join(", ")} } from "${key}"`).join("\n");
     const typeImportsCode = Object.keys(this.typeImports).map((key) => `import type { ${this.typeImports[key].join(", ")} } from "${key}"`).join("\n");
-    const codes = [importsCode, typeImportsCode].filter((code) => code);
+    const codes = [defaultImportsCode, importsCode, typeImportsCode].filter((code) => code);
     return codes.join("\n") + "\n";
   }
   getUseLoaderDataCode(spaces = 2) {
@@ -16249,6 +16219,14 @@ ${spacesStr}}`).join("\n" + spacesStr);
       this.imports[packagePath].push(componentName);
     }
   }
+  addDefaultImport(componentName, packagePath) {
+    if (!this.defaultImports[packagePath]) {
+      this.defaultImports[packagePath] = [];
+    }
+    if (!this.defaultImports[packagePath].find((name) => name === componentName)) {
+      this.defaultImports[packagePath].push(componentName);
+    }
+  }
   addTypeImport(componentName, packagePath) {
     if (!this.typeImports[packagePath]) {
       this.typeImports[packagePath] = [];
@@ -16368,7 +16346,7 @@ class ComponentCoder extends Coder {
     this.comsStore = comsStore;
     this.component = component;
     if (this.component.droppable) {
-      this.addImport("React", "react");
+      this.addDefaultImport("React", "react");
     }
     if (this.getXDataSchemas().length) {
       this.addTypeImport("TDatas", "@rxdrag/website-components");