@plitzi/plitzi-builder 0.37.6 → 0.37.7

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @plitzi/plitzi-builder
 
+## 0.37.7
+
+### Patch Changes
+
+- 4d10e0a: ## CDNs with several buckets
+
+  A CDN is the customer's own storage account — S3 or R2, which they run and pay for — and now holds any number of
+  buckets, each with its own configuration: its name at the provider, its region, `public` (served at its domain) or
+  `private` (no domain, read only by the platform with the CDN's credential).
+
+  - `Cdn` carries `buckets: CdnBucket[]`; `domain`, `visibility`, `bucketName` and `region` moved from the CDN to its
+    buckets. `Resource.bucketIdentifier` names the bucket a file is in.
+  - `SpaceAddCdn(name, provider, endpoint, buckets)` creates the account with its buckets; `SpaceUpdateCdn` changes the
+    account only. New `SpaceAddCdnBucket`, `SpaceUpdateCdnBucket` and `SpaceRemoveCdnBucket`.
+  - `SpaceResources`, `SpaceAddResource`, `SpaceRemoveResource` and `SpaceMoveResource` take `bucketIdentifier`.
+  - Server code — functions and runtime — goes in the space's oldest private bucket. A bucket that keeps code a version
+    runs can be neither made public, pointed at another bucket nor removed, and neither can its CDN.
+  - Builder: Resources shows each CDN with its buckets — add, edit and remove buckets, upload and browse per bucket; the
+    account (name, provider, endpoint, credential) is edited apart. Saving an element as a template picks a public
+    bucket (`elementAsTemplate({ cdnIdentifier, bucketIdentifier }, …)`).
+  - CLI: `plitzi upload plugin --bucket <identifier>` (with `--cdn` to narrow); only public buckets are offered, a private
+    one is refused.
+
+- Updated dependencies [4d10e0a]
+  - @plitzi/sdk-auth@0.37.7
+  - @plitzi/sdk-authoring@0.37.7
+  - @plitzi/sdk-dev-tools@0.37.7
+  - @plitzi/sdk-elements@0.37.7
+  - @plitzi/sdk-event-bridge@0.37.7
+  - @plitzi/sdk-interactions@0.37.7
+  - @plitzi/sdk-navigation@0.37.7
+  - @plitzi/sdk-plugins@0.37.7
+  - @plitzi/sdk-schema@0.37.7
+  - @plitzi/sdk-shared@0.37.7
+  - @plitzi/sdk-style@0.37.7
+  - @plitzi/sdk-variables@0.37.7
+  - @plitzi/plitzi-sdk@0.37.7
+
 ## 0.37.6
 
 ### Patch Changes

package/dist/modules/Builder/Models/TemplateForm.d.ts

@@ -1,16 +1,16 @@
-import { z } from 'zod';
 import { MouseEvent } from 'react';
-declare const templateFormSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    cdnIdentifier: z.ZodString;
-}, z.core.$strip>;
+/** What the form answers: the template, and the public bucket of which CDN it goes in. */
+export type TemplateFormValues = {
+    name: string;
+    description?: string;
+    cdnIdentifier: string;
+    bucketIdentifier: string;
+};
 export type TemplateFormProps = {
     name?: string;
     description?: string;
-    cdnIdentifier?: string;
     onClose?: (e?: MouseEvent) => void;
-    onSubmit?: (e: MouseEvent | undefined, values: z.infer<typeof templateFormSchema>) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: TemplateFormValues) => void;
 };
-declare const TemplateForm: ({ name, description, cdnIdentifier, onSubmit, onClose }: TemplateFormProps) => import('react').JSX.Element;
+declare const TemplateForm: ({ name, description, onSubmit, onClose }: TemplateFormProps) => import('react').JSX.Element;
 export default TemplateForm;

package/dist/modules/Functions/components/FunctionsOffer/FunctionsOffer.d.ts

@@ -5,7 +5,7 @@ export type FunctionsOfferProps = {
     onInstall?: () => void;
 };
 /**
- * The functions the space's template brought, offered to install: a space made from a template has no private CDN to
+ * The functions the space's template brought, offered to install: a space made from a template has no private bucket to
  * keep server code on at first, so they wait here until it has one. Installing saves them as the space's own.
  */
 declare const FunctionsOffer: ({ template, isInstalling, onInstall }: FunctionsOfferProps) => import('react').JSX.Element;

package/dist/modules/Resources/Models/CdnAccountFields.d.ts

@@ -0,0 +1,7 @@
+export type CdnAccountFieldsProps = {
+    provider: string;
+    onChangeProvider?: (value: string) => void;
+};
+/** A CDN account's fields — its name, its provider and, on R2, its endpoint — inside a form that holds them. */
+declare const CdnAccountFields: ({ provider, onChangeProvider }: CdnAccountFieldsProps) => import('react').JSX.Element;
+export default CdnAccountFields;

package/dist/modules/Resources/Models/CdnBucketFields.d.ts

@@ -0,0 +1,10 @@
+export type CdnBucketFieldsProps = {
+    provider: string;
+    visibility: string;
+};
+/**
+ * A bucket's fields — the bucket as the provider knows it, its region on S3, who may read it and, when public, where —
+ * inside a form that holds them.
+ */
+declare const CdnBucketFields: ({ provider, visibility }: CdnBucketFieldsProps) => import('react').JSX.Element;
+export default CdnBucketFields;

package/dist/modules/Resources/Models/ResourceCdnAccountForm.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { MouseEvent } from 'react';
+declare const resourceCdnAccountFormSchema: z.ZodObject<{
+    name: z.ZodString;
+    provider: z.ZodEnum<{
+        s3: "s3";
+        r2: "r2";
+    }>;
+    endpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResourceCdnAccountFormValues = z.infer<typeof resourceCdnAccountFormSchema>;
+export type ResourceCdnAccountFormProps = {
+    name: string;
+    provider: 's3' | 'r2';
+    endpoint?: string;
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: ResourceCdnAccountFormValues) => void;
+};
+/** A CDN's account — its name, provider and endpoint. Its buckets are changed one by one. */
+declare const ResourceCdnAccountForm: ({ name, provider, endpoint, onSubmit, onClose }: ResourceCdnAccountFormProps) => import('react').JSX.Element;
+export default ResourceCdnAccountForm;

package/dist/modules/Resources/Models/ResourceCdnBucketForm.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { CdnVisibility } from '@plitzi/sdk-shared';
+import { MouseEvent } from 'react';
+declare const bucketFormSchemaFor: (provider: "s3" | "r2") => z.ZodObject<{
+    bucketName: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
+    domain: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResourceCdnBucketFormValues = z.infer<ReturnType<typeof bucketFormSchemaFor>>;
+export type ResourceCdnBucketFormProps = {
+    /** The provider of the CDN it belongs to: an S3 bucket has a region of its own. */
+    provider: 's3' | 'r2';
+    name?: string;
+    bucketName?: string;
+    region?: string;
+    visibility?: CdnVisibility;
+    domain?: string;
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: ResourceCdnBucketFormValues) => void;
+};
+/** A bucket of a CDN, added or changed: what the builder calls it, and its configuration. */
+declare const ResourceCdnBucketForm: ({ provider, name, bucketName, region, visibility, domain, onSubmit, onClose }: ResourceCdnBucketFormProps) => import('react').JSX.Element;
+export default ResourceCdnBucketForm;

package/dist/modules/Resources/Models/ResourceCdnForm.d.ts

@@ -1,40 +1,25 @@
 import { z } from 'zod';
-import { CdnVisibility } from '@plitzi/sdk-shared';
 import { MouseEvent } from 'react';
-declare const resourceCdnFormSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    provider: z.ZodLiteral<"s3">;
-    name: z.ZodString;
+/** A new CDN: the customer's storage account and its first bucket — more are added to it afterwards. */
+declare const resourceCdnFormSchema: z.ZodObject<{
+    bucketName: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
     visibility: z.ZodEnum<{
         public: "public";
         private: "private";
     }>;
-    domain: z.ZodString;
-    region: z.ZodString;
-    endpoint: z.ZodOptional<z.ZodString>;
-    bucketName: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    provider: z.ZodLiteral<"r2">;
+    domain: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
-    visibility: z.ZodEnum<{
-        public: "public";
-        private: "private";
+    provider: z.ZodEnum<{
+        s3: "s3";
+        r2: "r2";
     }>;
-    domain: z.ZodString;
-    region: z.ZodDefault<z.ZodString>;
-    endpoint: z.ZodString;
-    bucketName: z.ZodString;
-}, z.core.$strip>], "provider">;
+    endpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResourceCdnFormValues = z.infer<typeof resourceCdnFormSchema>;
 export type ResourceCdnFormProps = {
-    className?: string;
-    name?: string;
-    domain?: string;
-    visibility?: CdnVisibility;
-    provider?: 's3' | 'r2';
-    region?: string;
-    endpoint?: string;
-    bucketName?: string;
     onClose?: (e?: MouseEvent) => void;
-    onSubmit?: (e: MouseEvent | undefined, values: z.infer<typeof resourceCdnFormSchema>) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: ResourceCdnFormValues) => void;
 };
-declare const ResourceCdnForm: ({ name, domain, visibility, provider, region, endpoint, bucketName, onSubmit, onClose }: ResourceCdnFormProps) => import('react').JSX.Element;
+declare const ResourceCdnForm: ({ onSubmit, onClose }: ResourceCdnFormProps) => import('react').JSX.Element;
 export default ResourceCdnForm;

package/dist/modules/Resources/Models/cdnSchemas.d.ts

@@ -0,0 +1,34 @@
+import { z, RefinementCtx } from 'zod';
+/** A CDN's account, as its forms take it: the customer's storage account — provider, and where R2 reaches it. */
+export declare const cdnAccountShape: {
+    name: z.ZodString;
+    provider: z.ZodEnum<{
+        s3: "s3";
+        r2: "r2";
+    }>;
+    endpoint: z.ZodOptional<z.ZodString>;
+};
+/** A bucket's configuration, as its forms take it. */
+export declare const cdnBucketShape: {
+    bucketName: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
+    domain: z.ZodOptional<z.ZodString>;
+};
+/** What an account needs beyond its shape: R2 is reached at an endpoint of its own. */
+export declare const checkCdnAccount: ({ provider, endpoint }: {
+    provider: "s3" | "r2";
+    endpoint?: string;
+}, ctx: RefinementCtx) => void;
+/**
+ * What a bucket needs beyond its shape: an S3 bucket lives in a region of its own, and a public bucket is read at its
+ * domain — a private one has none: only Plitzi reads it, with the CDN's credential.
+ */
+export declare const checkCdnBucket: (provider: "s3" | "r2", { region, visibility, domain }: {
+    region?: string;
+    visibility: "public" | "private";
+    domain?: string;
+}, ctx: RefinementCtx) => void;

package/dist/modules/Resources/components/Resource/Resource.d.ts

@@ -3,6 +3,7 @@ export type ResourceProps = {
     className?: string;
     id: string;
     cdnIdentifier: string;
+    bucketIdentifier: string;
     type?: TResourceType;
     src?: string;
     title?: string;
@@ -13,5 +14,5 @@ export type ResourceProps = {
     isLoading?: boolean;
     onRemove?: (id: string) => void;
 };
-declare const Resource: ({ className, id, cdnIdentifier, type, src, title, metadata, usedBy, directoryName, isLoading, onRemove }: ResourceProps) => import('react').JSX.Element;
+declare const Resource: ({ className, id, cdnIdentifier, bucketIdentifier, type, src, title, metadata, usedBy, directoryName, isLoading, onRemove }: ResourceProps) => import('react').JSX.Element;
 export default Resource;

package/dist/modules/Resources/components/Resource/subTypes/ResourceServerCode/ResourceServerCode.d.ts

@@ -9,9 +9,9 @@ export type ResourceServerCodeProps = {
     onRemove?: (e: MouseEvent) => void;
 };
 /**
- * A file of the space's server code on its private CDN — its functions or its runtime, kept by saves and pushes and
- * named by what it holds. No preview and no address: a private CDN serves nothing. What it shows is which versions run
- * it, so what nothing runs any more can be cleared from here.
+ * A file of the space's server code in its private bucket — its functions or its runtime, kept by saves and pushes
+ * and named by what it holds. No preview and no address: a private bucket serves nothing. What it shows is which
+ * versions run it, so what nothing runs any more can be cleared from here.
  */
 declare const ResourceServerCode: ({ className, id, usedBy, removing, isLoading, onRemove }: ResourceServerCodeProps) => import('react').JSX.Element;
 export default ResourceServerCode;

package/dist/modules/Resources/components/ResourceManager/ResourceManager.d.ts

@@ -2,9 +2,11 @@ import { ResourceFile, ResourceWithFile } from '@plitzi/sdk-shared';
 export type ResourceManagerProps = {
     className?: string;
     cdnIdentifier?: string;
+    /** Which of the CDN's buckets the files go in — a public one. */
+    bucketIdentifier?: string;
     uploadTypes?: string[];
     onUploaded?: (resource: ResourceWithFile) => void;
     onUploadAdded?: (file: ResourceFile) => boolean;
 };
-declare const ResourceManager: ({ className, cdnIdentifier, uploadTypes, onUploaded, onUploadAdded }: ResourceManagerProps) => import('react').JSX.Element;
+declare const ResourceManager: ({ className, cdnIdentifier, bucketIdentifier, uploadTypes, onUploaded, onUploadAdded }: ResourceManagerProps) => import('react').JSX.Element;
 export default ResourceManager;

package/dist/modules/Resources/components/ResourceManager/TemporalResource.d.ts

@@ -2,6 +2,7 @@ import { PluginManifest, ResourceFile, ResourceType as TResourceType, ResourceWi
 export type TemporalResourceProps = {
     className?: string;
     cdnIdentifier?: string;
+    bucketIdentifier?: string;
     id?: string;
     file?: ResourceFile;
     type?: TResourceType;
@@ -11,5 +12,5 @@ export type TemporalResourceProps = {
     onUploadCancel?: (file: File) => void;
     onError?: (e: Error) => void;
 };
-declare const TemporalResource: ({ cdnIdentifier, id, type, title, className, file, metadata, onUploaded, onError: onErrorProp, onUploadCancel }: TemporalResourceProps) => import('react').JSX.Element;
+declare const TemporalResource: ({ cdnIdentifier, bucketIdentifier, id, type, title, className, file, metadata, onUploaded, onError: onErrorProp, onUploadCancel }: TemporalResourceProps) => import('react').JSX.Element;
 export default TemporalResource;

package/dist/modules/Resources/components/ResourcesCdn/ResourcesCdn.d.ts

@@ -1,15 +1,15 @@
 import { Cdn } from '@plitzi/sdk-shared';
 export type ResourcesCdnProps = {
-    /** The CDN as the space's list gives it — what its settings open with. */
+    /** The CDN as the space's list gives it: its account and its buckets. */
     cdn: Cdn;
-    identifier: string;
-    name: string;
-    prefix: string;
-    credentialIdentifier?: string;
     isCollapsed?: boolean;
     onCollapse?: (category: string, isCollapsed: boolean) => void;
     onChange?: (identifier: string) => void;
     onRemove?: (identifier: string) => void;
 };
-declare const ResourcesCdn: ({ cdn, identifier, name, prefix, credentialIdentifier, isCollapsed, onCollapse, onChange, onRemove }: ResourcesCdnProps) => import('react').JSX.Element;
+/**
+ * A CDN — the customer's own storage account — and its buckets, each with its own configuration and files. The account
+ * holds the credential every bucket is opened with.
+ */
+declare const ResourcesCdn: ({ cdn, isCollapsed, onCollapse, onChange, onRemove }: ResourcesCdnProps) => import('react').JSX.Element;
 export default ResourcesCdn;

package/dist/modules/Resources/components/ResourcesCdnBucket/ResourcesCdnBucket.d.ts

@@ -0,0 +1,18 @@
+import { CdnBucket } from '@plitzi/sdk-shared';
+export type ResourcesCdnBucketProps = {
+    cdnIdentifier: string;
+    /** The CDN's provider: what a bucket's settings ask for depends on it. */
+    provider: 's3' | 'r2';
+    bucket: CdnBucket;
+    /** The folder every file of the space is kept under in its buckets. */
+    prefix: string;
+    /** The CDN changed — a bucket added, edited or removed — and its list is read again. */
+    onChange?: () => void;
+};
+/**
+ * One bucket of a CDN and the space's files in it. A public one takes uploads — plugins, images, templates — and serves
+ * them at its domain; a private one keeps the space's server code, written when it is saved or pushed, and serves
+ * nothing.
+ */
+declare const ResourcesCdnBucket: ({ cdnIdentifier, provider, bucket, prefix, onChange }: ResourcesCdnBucketProps) => import('react').JSX.Element;
+export default ResourcesCdnBucket;

package/dist/modules/Resources/components/ResourcesCdnBucket/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ResourcesCdnBucket } from './ResourcesCdnBucket';
+export * from './ResourcesCdnBucket';
+export default ResourcesCdnBucket;

package/dist/modules/Resources/components/ResourcesList/ListHelper.d.ts

@@ -1,5 +1,5 @@
 import { ResourceDirectory } from './ResourcesList';
-import { Resource } from '@plitzi/sdk-shared';
+import { CdnVisibility, Resource } from '@plitzi/sdk-shared';
 declare const sortDirectories: (a: ResourceDirectory, b: ResourceDirectory) => number;
-declare const getDirectories: (prefix?: string, items?: Resource[]) => ResourceDirectory[];
+declare const getDirectories: (prefix?: string, items?: Resource[], visibility?: CdnVisibility) => ResourceDirectory[];
 export { getDirectories, sortDirectories };

package/dist/modules/Resources/components/ResourcesList/ListHelper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Resources/components/ResourcesList/ResourceDirectory.d.ts

@@ -7,9 +7,10 @@ export type ResourcesDirectoryProps = {
     canDrop?: boolean;
     canRemove?: boolean;
     cdnIdentifier: string;
+    bucketIdentifier: string;
     onChange?: () => void;
     onRemove?: (item: TResource) => void;
     onRemoveDirectory?: (name?: string) => void;
 };
-declare const ResourceDirectory: ({ className, name, items, isDefault, canRemove, canDrop, cdnIdentifier, onChange, onRemove, onRemoveDirectory }: ResourcesDirectoryProps) => import('react').JSX.Element;
+declare const ResourceDirectory: ({ className, name, items, isDefault, canRemove, canDrop, cdnIdentifier, bucketIdentifier, onChange, onRemove, onRemoveDirectory }: ResourcesDirectoryProps) => import('react').JSX.Element;
 export default ResourceDirectory;

package/dist/modules/Resources/components/ResourcesList/ResourcesList.d.ts

@@ -1,9 +1,12 @@
-import { Resource as TResource } from '@plitzi/sdk-shared';
+import { CdnVisibility, Resource as TResource } from '@plitzi/sdk-shared';
 export type ResourcesListProps = {
     className?: string;
     items: TResource[];
     prefix: string;
     cdnIdentifier: string;
+    bucketIdentifier: string;
+    /** A private bucket takes no upload: it lists its server code, and offers no folder to add. */
+    visibility?: CdnVisibility;
     onChange?: () => void;
     onRemove?: (item: TResource) => void;
 };
@@ -14,5 +17,5 @@ export type ResourceDirectory = {
     isDefault: boolean;
     canRemove: boolean;
 };
-declare const ResourcesList: ({ className, prefix, items, cdnIdentifier, onChange, onRemove }: ResourcesListProps) => import('react').JSX.Element;
+declare const ResourcesList: ({ className, prefix, items, cdnIdentifier, bucketIdentifier, visibility, onChange, onRemove }: ResourcesListProps) => import('react').JSX.Element;
 export default ResourcesList;

package/dist/package.json.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
   "name": "@plitzi/plitzi-builder",
-  "version": "0.37.6",
+  "version": "0.37.7",
   "homepage": "./",
   "license": "AGPL-3.0",
   "files": [