@webiny/api-dashboard 0.0.0-stage → 0.0.0-unstable.7c2def32a7

package/DashboardAppFeature.d.ts

@@ -0,0 +1,9 @@
+import type { Container } from "@webiny/feature/api";
+/**
+ * Stores each identity's admin dashboard layout in the key-value store, keyed by the identity ID,
+ * so users and identities don't need to know dashboards exist.
+ */
+export declare const DashboardAppFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/DashboardAppFeature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListDashboardsFeature } from "./features/ListDashboards/index.js";
+import { UpdateDashboardFeature } from "./features/UpdateDashboard/index.js";
+import { DashboardGraphQLSchema } from "./graphql/DashboardGraphQLSchema.js";
+const DashboardAppFeature = createFeature({
+    name: "DashboardApp",
+    register (container) {
+        ListDashboardsFeature.register(container);
+        UpdateDashboardFeature.register(container);
+        container.register(DashboardGraphQLSchema);
+    }
+});
+export { DashboardAppFeature };
+
+//# sourceMappingURL=DashboardAppFeature.js.map

package/DashboardAppFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardAppFeature.js","sources":["../src/DashboardAppFeature.ts"],"sourcesContent":["import type { Container } from \"@webiny/feature/api\";\nimport { createFeature } from \"@webiny/feature/api\";\nimport { ListDashboardsFeature } from \"~/features/ListDashboards/index.js\";\nimport { UpdateDashboardFeature } from \"~/features/UpdateDashboard/index.js\";\nimport { DashboardGraphQLSchema } from \"~/graphql/DashboardGraphQLSchema.js\";\n\n/**\n * Stores each identity's admin dashboard layout in the key-value store, keyed by the identity ID,\n * so users and identities don't need to know dashboards exist.\n */\nexport const DashboardAppFeature = createFeature({\n    name: \"DashboardApp\",\n    register(container: Container) {\n        ListDashboardsFeature.register(container);\n        UpdateDashboardFeature.register(container);\n        container.register(DashboardGraphQLSchema);\n    }\n});\n"],"names":["DashboardAppFeature","createFeature","container","ListDashboardsFeature","UpdateDashboardFeature","DashboardGraphQLSchema"],"mappings":";;;;AAUO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBC,sBAAsB,QAAQ,CAACD;QAC/BE,uBAAuB,QAAQ,CAACF;QAChCA,UAAU,QAAQ,CAACG;IACvB;AACJ"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,11 @@
-# Temporary Holding Version
+# @webiny/api-dashboard
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/domain/dashboardKey.d.ts

@@ -0,0 +1 @@
+export declare const createDashboardKey: (ownerId: string) => string;

package/domain/dashboardKey.js

@@ -0,0 +1,4 @@
+const createDashboardKey = (ownerId)=>`adminDashboard:${ownerId}`;
+export { createDashboardKey };
+
+//# sourceMappingURL=dashboardKey.js.map

package/domain/dashboardKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/dashboardKey.js","sources":["../../src/domain/dashboardKey.ts"],"sourcesContent":["// Each identity has one layout per tenant. The key-value store already scopes keys by tenant.\nexport const createDashboardKey = (ownerId: string): string => {\n    return `adminDashboard:${ownerId}`;\n};\n"],"names":["createDashboardKey","ownerId"],"mappings":"AACO,MAAMA,qBAAqB,CAACC,UACxB,CAAC,eAAe,EAAEA,SAAS"}

package/domain/errors.d.ts

@@ -0,0 +1,15 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class DashboardNotAuthenticatedError extends BaseError {
+    readonly code: "Dashboard/NotAuthenticated";
+    constructor();
+}
+export declare class DashboardPersistenceError extends BaseError {
+    readonly code: "Dashboard/PersistenceError";
+    constructor(error: Error);
+}
+export declare class DashboardValidationError extends BaseError<{
+    message: string;
+}> {
+    readonly code: "Dashboard/Validation";
+    constructor(message: string);
+}

package/domain/errors.js

@@ -0,0 +1,28 @@
+import { BaseError } from "@webiny/feature/api";
+class DashboardNotAuthenticatedError extends BaseError {
+    constructor(){
+        super({
+            message: "Only a signed-in identity has a dashboard."
+        }), this.code = "Dashboard/NotAuthenticated";
+    }
+}
+class DashboardPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message
+        }), this.code = "Dashboard/PersistenceError";
+    }
+}
+class DashboardValidationError extends BaseError {
+    constructor(message){
+        super({
+            message,
+            data: {
+                message
+            }
+        }), this.code = "Dashboard/Validation";
+    }
+}
+export { DashboardNotAuthenticatedError, DashboardPersistenceError, DashboardValidationError };
+
+//# sourceMappingURL=errors.js.map

package/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/errors.js","sources":["../../src/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class DashboardNotAuthenticatedError extends BaseError {\n    override readonly code = \"Dashboard/NotAuthenticated\" as const;\n\n    constructor() {\n        super({\n            message: \"Only a signed-in identity has a dashboard.\"\n        });\n    }\n}\n\nexport class DashboardPersistenceError extends BaseError {\n    override readonly code = \"Dashboard/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: error.message\n        });\n    }\n}\n\nexport class DashboardValidationError extends BaseError<{ message: string }> {\n    override readonly code = \"Dashboard/Validation\" as const;\n\n    constructor(message: string) {\n        super({\n            message,\n            data: { message }\n        });\n    }\n}\n"],"names":["DashboardNotAuthenticatedError","BaseError","DashboardPersistenceError","error","DashboardValidationError","message"],"mappings":";AAEO,MAAMA,uCAAuCC;IAGhD,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMC,kCAAkCD;IAG3C,YAAYE,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAASA,MAAM,OAAO;QAC1B,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMC,iCAAiCH;IAG1C,YAAYI,OAAe,CAAE;QACzB,KAAK,CAAC;YACFA;YACA,MAAM;gBAAEA;YAAQ;QACpB,SANc,IAAI,GAAG;IAOzB;AACJ"}

package/domain/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A user's admin dashboard layout: an ordered list of widget names per column (`columns[i]` is
+ * column i), the widgets the user removed (`hidden`), and how many columns the user chose.
+ */
+export interface DashboardLayout {
+    columns: string[][];
+    hidden: string[];
+    columnCount: number;
+}

package/features/ListDashboards/ListDashboardsRepository.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { ListDashboardsRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { DashboardLayout } from "../../domain/types.js";
+declare class ListDashboardsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private keyValueStore;
+    constructor(keyValueStore: KeyValueStore.Interface);
+    get(ownerId: string): Promise<Result<DashboardLayout | null, RepositoryAbstraction.Error>>;
+}
+export declare const ListDashboardsRepository: typeof ListDashboardsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListDashboardsRepository>;
+};
+export {};

package/features/ListDashboards/ListDashboardsRepository.js

@@ -0,0 +1,28 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { ListDashboardsRepository } from "./abstractions.js";
+import { DashboardPersistenceError } from "../../domain/errors.js";
+import { createDashboardKey } from "../../domain/dashboardKey.js";
+class ListDashboardsRepositoryImpl {
+    constructor(keyValueStore){
+        this.keyValueStore = keyValueStore;
+    }
+    async get(ownerId) {
+        const key = createDashboardKey(ownerId);
+        const result = await this.keyValueStore.get(key);
+        if (result.isFail()) {
+            if ("KeyValueStore/KeyNotFound" === result.error.code) return Result.ok(null);
+            return Result.fail(new DashboardPersistenceError(result.error));
+        }
+        return Result.ok(result.value);
+    }
+}
+const ListDashboardsRepository_ListDashboardsRepository = ListDashboardsRepository.createImplementation({
+    implementation: ListDashboardsRepositoryImpl,
+    dependencies: [
+        KeyValueStore
+    ]
+});
+export { ListDashboardsRepository_ListDashboardsRepository as ListDashboardsRepository };
+
+//# sourceMappingURL=ListDashboardsRepository.js.map

package/features/ListDashboards/ListDashboardsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListDashboards/ListDashboardsRepository.js","sources":["../../../src/features/ListDashboards/ListDashboardsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { KeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\nimport { ListDashboardsRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { DashboardPersistenceError } from \"~/domain/errors.js\";\nimport { createDashboardKey } from \"~/domain/dashboardKey.js\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\n\nclass ListDashboardsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(private keyValueStore: KeyValueStore.Interface) {}\n\n    async get(\n        ownerId: string\n    ): Promise<Result<DashboardLayout | null, RepositoryAbstraction.Error>> {\n        const key = createDashboardKey(ownerId);\n        const result = await this.keyValueStore.get<DashboardLayout>(key);\n        if (result.isFail()) {\n            if (result.error.code === \"KeyValueStore/KeyNotFound\") {\n                return Result.ok(null);\n            }\n            return Result.fail(new DashboardPersistenceError(result.error));\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const ListDashboardsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListDashboardsRepositoryImpl,\n    dependencies: [KeyValueStore]\n});\n"],"names":["ListDashboardsRepositoryImpl","keyValueStore","ownerId","key","createDashboardKey","result","Result","DashboardPersistenceError","ListDashboardsRepository","RepositoryAbstraction","KeyValueStore"],"mappings":";;;;;AAOA,MAAMA;IACF,YAAoBC,aAAsC,CAAE;aAAxCA,aAAa,GAAbA;IAAyC;IAE7D,MAAM,IACFC,OAAe,EACqD;QACpE,MAAMC,MAAMC,mBAAmBF;QAC/B,MAAMG,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAkBF;QAC7D,IAAIE,OAAO,MAAM,IAAI;YACjB,IAAIA,AAAsB,gCAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,EAAE,CAAC;YAErB,OAAOA,OAAO,IAAI,CAAC,IAAIC,0BAA0BF,OAAO,KAAK;QACjE;QAEA,OAAOC,OAAO,EAAE,CAACD,OAAO,KAAK;IACjC;AACJ;AAEO,MAAMG,oDAA2BC,yBAAAA,oBAA0C,CAAC;IAC/E,gBAAgBT;IAChB,cAAc;QAACU;KAAc;AACjC"}

package/features/ListDashboards/ListDashboardsUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListDashboardsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListDashboardsRepository } from "./abstractions.js";
+import type { DashboardLayout } from "../../domain/types.js";
+declare class ListDashboardsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, repository: ListDashboardsRepository.Interface);
+    execute(): Promise<Result<DashboardLayout[], UseCaseAbstraction.Error>>;
+}
+export declare const ListDashboardsUseCase: typeof ListDashboardsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListDashboardsUseCase>;
+};
+export {};

package/features/ListDashboards/ListDashboardsUseCase.js

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListDashboardsRepository, ListDashboardsUseCase } from "./abstractions.js";
+import { DashboardNotAuthenticatedError } from "../../domain/errors.js";
+class ListDashboardsUseCaseImpl {
+    constructor(identityContext, repository){
+        this.identityContext = identityContext;
+        this.repository = repository;
+    }
+    async execute() {
+        const identity = this.identityContext.getIdentity();
+        if (!identity || identity.isAnonymous()) return Result.fail(new DashboardNotAuthenticatedError());
+        const result = await this.repository.get(identity.id);
+        if (result.isFail()) return Result.fail(result.error);
+        if (!result.value) return Result.ok([]);
+        return Result.ok([
+            result.value
+        ]);
+    }
+}
+const ListDashboardsUseCase_ListDashboardsUseCase = ListDashboardsUseCase.createImplementation({
+    implementation: ListDashboardsUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        ListDashboardsRepository
+    ]
+});
+export { ListDashboardsUseCase_ListDashboardsUseCase as ListDashboardsUseCase };
+
+//# sourceMappingURL=ListDashboardsUseCase.js.map

package/features/ListDashboards/ListDashboardsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListDashboards/ListDashboardsUseCase.js","sources":["../../../src/features/ListDashboards/ListDashboardsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { ListDashboardsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { ListDashboardsRepository } from \"./abstractions.js\";\nimport { DashboardNotAuthenticatedError } from \"~/domain/errors.js\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\n\nclass ListDashboardsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private repository: ListDashboardsRepository.Interface\n    ) {}\n\n    async execute(): Promise<Result<DashboardLayout[], UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n        if (!identity || identity.isAnonymous()) {\n            return Result.fail(new DashboardNotAuthenticatedError());\n        }\n\n        const result = await this.repository.get(identity.id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n        if (!result.value) {\n            return Result.ok([]);\n        }\n        return Result.ok([result.value]);\n    }\n}\n\nexport const ListDashboardsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListDashboardsUseCaseImpl,\n    dependencies: [IdentityContext, ListDashboardsRepository]\n});\n"],"names":["ListDashboardsUseCaseImpl","identityContext","repository","identity","Result","DashboardNotAuthenticatedError","result","ListDashboardsUseCase","UseCaseAbstraction","IdentityContext","ListDashboardsRepository"],"mappings":";;;;AAOA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,UAA8C,CACxD;aAFUD,eAAe,GAAfA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,UAAwE;QAC1E,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,IAAI,CAACA,YAAYA,SAAS,WAAW,IACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACH,SAAS,EAAE;QACpD,IAAIG,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAEnC,IAAI,CAACA,OAAO,KAAK,EACb,OAAOF,OAAO,EAAE,CAAC,EAAE;QAEvB,OAAOA,OAAO,EAAE,CAAC;YAACE,OAAO,KAAK;SAAC;IACnC;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgBR;IAChB,cAAc;QAACS;QAAiBC;KAAyB;AAC7D"}

package/features/ListDashboards/abstractions.d.ts

@@ -0,0 +1,34 @@
+import { Result } from "@webiny/feature/api";
+import type { DashboardLayout } from "../../domain/types.js";
+import type { DashboardNotAuthenticatedError } from "../../domain/errors.js";
+import type { DashboardPersistenceError } from "../../domain/errors.js";
+/**
+ * ListDashboards Use Case - Returns the current identity's dashboards. Each identity has at most
+ * one today, and none until it customizes the dashboard.
+ */
+export interface IListDashboardsUseCase {
+    execute(): Promise<Result<DashboardLayout[], UseCaseError>>;
+}
+export interface IListDashboardsUseCaseErrors {
+    notAuthenticated: DashboardNotAuthenticatedError;
+    persistence: DashboardPersistenceError;
+}
+type UseCaseError = IListDashboardsUseCaseErrors[keyof IListDashboardsUseCaseErrors];
+export declare const ListDashboardsUseCase: import("@webiny/di").Abstraction<IListDashboardsUseCase>;
+export declare namespace ListDashboardsUseCase {
+    type Interface = IListDashboardsUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * ListDashboardsRepository - Loads an owner's dashboard layout from storage, or `null` if none is stored.
+ */
+export interface IListDashboardsRepository {
+    get(ownerId: string): Promise<Result<DashboardLayout | null, RepositoryError>>;
+}
+type RepositoryError = DashboardPersistenceError;
+export declare const ListDashboardsRepository: import("@webiny/di").Abstraction<IListDashboardsRepository>;
+export declare namespace ListDashboardsRepository {
+    type Interface = IListDashboardsRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/ListDashboards/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListDashboardsUseCase = createAbstraction("ListDashboardsUseCase");
+const ListDashboardsRepository = createAbstraction("ListDashboardsRepository");
+export { ListDashboardsRepository, ListDashboardsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ListDashboards/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListDashboards/abstractions.js","sources":["../../../src/features/ListDashboards/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\nimport type { DashboardNotAuthenticatedError } from \"~/domain/errors.js\";\nimport type { DashboardPersistenceError } from \"~/domain/errors.js\";\n\n/**\n * ListDashboards Use Case - Returns the current identity's dashboards. Each identity has at most\n * one today, and none until it customizes the dashboard.\n */\nexport interface IListDashboardsUseCase {\n    execute(): Promise<Result<DashboardLayout[], UseCaseError>>;\n}\n\nexport interface IListDashboardsUseCaseErrors {\n    notAuthenticated: DashboardNotAuthenticatedError;\n    persistence: DashboardPersistenceError;\n}\n\ntype UseCaseError = IListDashboardsUseCaseErrors[keyof IListDashboardsUseCaseErrors];\n\nexport const ListDashboardsUseCase =\n    createAbstraction<IListDashboardsUseCase>(\"ListDashboardsUseCase\");\n\nexport namespace ListDashboardsUseCase {\n    export type Interface = IListDashboardsUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * ListDashboardsRepository - Loads an owner's dashboard layout from storage, or `null` if none is stored.\n */\nexport interface IListDashboardsRepository {\n    get(ownerId: string): Promise<Result<DashboardLayout | null, RepositoryError>>;\n}\n\ntype RepositoryError = DashboardPersistenceError;\n\nexport const ListDashboardsRepository = createAbstraction<IListDashboardsRepository>(\n    \"ListDashboardsRepository\"\n);\n\nexport namespace ListDashboardsRepository {\n    export type Interface = IListDashboardsRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["ListDashboardsUseCase","createAbstraction","ListDashboardsRepository"],"mappings":";AAqBO,MAAMA,wBACTC,kBAA0C;AAgBvC,MAAMC,2BAA2BD,kBACpC"}

package/features/ListDashboards/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ListDashboardsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ListDashboards/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListDashboardsUseCase } from "./ListDashboardsUseCase.js";
+import { ListDashboardsRepository } from "./ListDashboardsRepository.js";
+const ListDashboardsFeature = createFeature({
+    name: "ListDashboards",
+    register (container) {
+        container.register(ListDashboardsUseCase);
+        container.register(ListDashboardsRepository).inSingletonScope();
+    }
+});
+export { ListDashboardsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/ListDashboards/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListDashboards/feature.js","sources":["../../../src/features/ListDashboards/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListDashboardsUseCase } from \"./ListDashboardsUseCase.js\";\nimport { ListDashboardsRepository } from \"./ListDashboardsRepository.js\";\n\nexport const ListDashboardsFeature = createFeature({\n    name: \"ListDashboards\",\n    register(container) {\n        container.register(ListDashboardsUseCase);\n        container.register(ListDashboardsRepository).inSingletonScope();\n    }\n});\n"],"names":["ListDashboardsFeature","createFeature","container","ListDashboardsUseCase","ListDashboardsRepository"],"mappings":";;;AAIO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,0BAA0B,gBAAgB;IACjE;AACJ"}

package/features/ListDashboards/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { ListDashboardsFeature } from "./feature.js";

package/features/ListDashboards/index.js

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { ListDashboardsFeature } from "./feature.js";

package/features/UpdateDashboard/UpdateDashboardRepository.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { UpdateDashboardRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { DashboardLayout } from "../../domain/types.js";
+declare class UpdateDashboardRepositoryImpl implements RepositoryAbstraction.Interface {
+    private keyValueStore;
+    constructor(keyValueStore: KeyValueStore.Interface);
+    save(ownerId: string, layout: DashboardLayout): Promise<Result<DashboardLayout, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateDashboardRepository: typeof UpdateDashboardRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateDashboardRepository>;
+};
+export {};

package/features/UpdateDashboard/UpdateDashboardRepository.js

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { UpdateDashboardRepository } from "./abstractions.js";
+import { DashboardPersistenceError } from "../../domain/errors.js";
+import { createDashboardKey } from "../../domain/dashboardKey.js";
+class UpdateDashboardRepositoryImpl {
+    constructor(keyValueStore){
+        this.keyValueStore = keyValueStore;
+    }
+    async save(ownerId, layout) {
+        const key = createDashboardKey(ownerId);
+        const result = await this.keyValueStore.set(key, layout);
+        if (result.isFail()) return Result.fail(new DashboardPersistenceError(result.error));
+        return Result.ok(layout);
+    }
+}
+const UpdateDashboardRepository_UpdateDashboardRepository = UpdateDashboardRepository.createImplementation({
+    implementation: UpdateDashboardRepositoryImpl,
+    dependencies: [
+        KeyValueStore
+    ]
+});
+export { UpdateDashboardRepository_UpdateDashboardRepository as UpdateDashboardRepository };
+
+//# sourceMappingURL=UpdateDashboardRepository.js.map

package/features/UpdateDashboard/UpdateDashboardRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateDashboard/UpdateDashboardRepository.js","sources":["../../../src/features/UpdateDashboard/UpdateDashboardRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { KeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\nimport { UpdateDashboardRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { DashboardPersistenceError } from \"~/domain/errors.js\";\nimport { createDashboardKey } from \"~/domain/dashboardKey.js\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\n\nclass UpdateDashboardRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(private keyValueStore: KeyValueStore.Interface) {}\n\n    async save(\n        ownerId: string,\n        layout: DashboardLayout\n    ): Promise<Result<DashboardLayout, RepositoryAbstraction.Error>> {\n        const key = createDashboardKey(ownerId);\n        const result = await this.keyValueStore.set(key, layout);\n        if (result.isFail()) {\n            return Result.fail(new DashboardPersistenceError(result.error));\n        }\n\n        return Result.ok(layout);\n    }\n}\n\nexport const UpdateDashboardRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateDashboardRepositoryImpl,\n    dependencies: [KeyValueStore]\n});\n"],"names":["UpdateDashboardRepositoryImpl","keyValueStore","ownerId","layout","key","createDashboardKey","result","Result","DashboardPersistenceError","UpdateDashboardRepository","RepositoryAbstraction","KeyValueStore"],"mappings":";;;;;AAOA,MAAMA;IACF,YAAoBC,aAAsC,CAAE;aAAxCA,aAAa,GAAbA;IAAyC;IAE7D,MAAM,KACFC,OAAe,EACfC,MAAuB,EACsC;QAC7D,MAAMC,MAAMC,mBAAmBH;QAC/B,MAAMI,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAACF,KAAKD;QACjD,IAAIG,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,0BAA0BF,OAAO,KAAK;QAGjE,OAAOC,OAAO,EAAE,CAACJ;IACrB;AACJ;AAEO,MAAMM,sDAA4BC,0BAAAA,oBAA0C,CAAC;IAChF,gBAAgBV;IAChB,cAAc;QAACW;KAAc;AACjC"}

package/features/UpdateDashboard/UpdateDashboardUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { UpdateDashboardUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { UpdateDashboardRepository } from "./abstractions.js";
+import type { DashboardLayout } from "../../domain/types.js";
+declare class UpdateDashboardUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, repository: UpdateDashboardRepository.Interface);
+    execute(layout: DashboardLayout): Promise<Result<DashboardLayout, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateDashboardUseCase: typeof UpdateDashboardUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateDashboardUseCase>;
+};
+export {};

package/features/UpdateDashboard/UpdateDashboardUseCase.js

@@ -0,0 +1,31 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { UpdateDashboardRepository, UpdateDashboardUseCase } from "./abstractions.js";
+import { DashboardNotAuthenticatedError, DashboardValidationError } from "../../domain/errors.js";
+import { updateDashboardValidation } from "./schema.js";
+class UpdateDashboardUseCaseImpl {
+    constructor(identityContext, repository){
+        this.identityContext = identityContext;
+        this.repository = repository;
+    }
+    async execute(layout) {
+        const identity = this.identityContext.getIdentity();
+        if (!identity || identity.isAnonymous()) return Result.fail(new DashboardNotAuthenticatedError());
+        const validation = updateDashboardValidation.safeParse(layout);
+        if (!validation.success) {
+            const [issue] = validation.error.issues;
+            return Result.fail(new DashboardValidationError(issue.message));
+        }
+        return await this.repository.save(identity.id, validation.data);
+    }
+}
+const UpdateDashboardUseCase_UpdateDashboardUseCase = UpdateDashboardUseCase.createImplementation({
+    implementation: UpdateDashboardUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        UpdateDashboardRepository
+    ]
+});
+export { UpdateDashboardUseCase_UpdateDashboardUseCase as UpdateDashboardUseCase };
+
+//# sourceMappingURL=UpdateDashboardUseCase.js.map

package/features/UpdateDashboard/UpdateDashboardUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateDashboard/UpdateDashboardUseCase.js","sources":["../../../src/features/UpdateDashboard/UpdateDashboardUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { UpdateDashboardUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UpdateDashboardRepository } from \"./abstractions.js\";\nimport { DashboardNotAuthenticatedError } from \"~/domain/errors.js\";\nimport { DashboardValidationError } from \"~/domain/errors.js\";\nimport { updateDashboardValidation } from \"./schema.js\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\n\nclass UpdateDashboardUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private repository: UpdateDashboardRepository.Interface\n    ) {}\n\n    async execute(\n        layout: DashboardLayout\n    ): Promise<Result<DashboardLayout, UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n        if (!identity || identity.isAnonymous()) {\n            return Result.fail(new DashboardNotAuthenticatedError());\n        }\n\n        const validation = updateDashboardValidation.safeParse(layout);\n        if (!validation.success) {\n            const [issue] = validation.error.issues;\n            return Result.fail(new DashboardValidationError(issue.message));\n        }\n\n        return await this.repository.save(identity.id, validation.data);\n    }\n}\n\nexport const UpdateDashboardUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateDashboardUseCaseImpl,\n    dependencies: [IdentityContext, UpdateDashboardRepository]\n});\n"],"names":["UpdateDashboardUseCaseImpl","identityContext","repository","layout","identity","Result","DashboardNotAuthenticatedError","validation","updateDashboardValidation","issue","DashboardValidationError","UpdateDashboardUseCase","UseCaseAbstraction","IdentityContext","UpdateDashboardRepository"],"mappings":";;;;;AASA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,UAA+C,CACzD;aAFUD,eAAe,GAAfA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QACFC,MAAuB,EACmC;QAC1D,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,IAAI,CAACA,YAAYA,SAAS,WAAW,IACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,aAAaC,0BAA0B,SAAS,CAACL;QACvD,IAAI,CAACI,WAAW,OAAO,EAAE;YACrB,MAAM,CAACE,MAAM,GAAGF,WAAW,KAAK,CAAC,MAAM;YACvC,OAAOF,OAAO,IAAI,CAAC,IAAIK,yBAAyBD,MAAM,OAAO;QACjE;QAEA,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAACL,SAAS,EAAE,EAAEG,WAAW,IAAI;IAClE;AACJ;AAEO,MAAMI,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBZ;IAChB,cAAc;QAACa;QAAiBC;KAA0B;AAC9D"}

package/features/UpdateDashboard/abstractions.d.ts

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import type { DashboardLayout } from "../../domain/types.js";
+import type { DashboardNotAuthenticatedError } from "../../domain/errors.js";
+import type { DashboardPersistenceError } from "../../domain/errors.js";
+import type { DashboardValidationError } from "../../domain/errors.js";
+/**
+ * UpdateDashboard Use Case - Stores the current identity's dashboard, creating it on first use.
+ */
+export interface IUpdateDashboardUseCase {
+    execute(layout: DashboardLayout): Promise<Result<DashboardLayout, UseCaseError>>;
+}
+export interface IUpdateDashboardUseCaseErrors {
+    notAuthenticated: DashboardNotAuthenticatedError;
+    validation: DashboardValidationError;
+    persistence: DashboardPersistenceError;
+}
+type UseCaseError = IUpdateDashboardUseCaseErrors[keyof IUpdateDashboardUseCaseErrors];
+export declare const UpdateDashboardUseCase: import("@webiny/di").Abstraction<IUpdateDashboardUseCase>;
+export declare namespace UpdateDashboardUseCase {
+    type Interface = IUpdateDashboardUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * UpdateDashboardRepository - Writes an owner's dashboard layout to storage.
+ */
+export interface IUpdateDashboardRepository {
+    save(ownerId: string, layout: DashboardLayout): Promise<Result<DashboardLayout, RepositoryError>>;
+}
+type RepositoryError = DashboardPersistenceError;
+export declare const UpdateDashboardRepository: import("@webiny/di").Abstraction<IUpdateDashboardRepository>;
+export declare namespace UpdateDashboardRepository {
+    type Interface = IUpdateDashboardRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/UpdateDashboard/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const UpdateDashboardUseCase = createAbstraction("UpdateDashboardUseCase");
+const UpdateDashboardRepository = createAbstraction("UpdateDashboardRepository");
+export { UpdateDashboardRepository, UpdateDashboardUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/UpdateDashboard/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateDashboard/abstractions.js","sources":["../../../src/features/UpdateDashboard/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\nimport type { DashboardNotAuthenticatedError } from \"~/domain/errors.js\";\nimport type { DashboardPersistenceError } from \"~/domain/errors.js\";\nimport type { DashboardValidationError } from \"~/domain/errors.js\";\n\n/**\n * UpdateDashboard Use Case - Stores the current identity's dashboard, creating it on first use.\n */\nexport interface IUpdateDashboardUseCase {\n    execute(layout: DashboardLayout): Promise<Result<DashboardLayout, UseCaseError>>;\n}\n\nexport interface IUpdateDashboardUseCaseErrors {\n    notAuthenticated: DashboardNotAuthenticatedError;\n    validation: DashboardValidationError;\n    persistence: DashboardPersistenceError;\n}\n\ntype UseCaseError = IUpdateDashboardUseCaseErrors[keyof IUpdateDashboardUseCaseErrors];\n\nexport const UpdateDashboardUseCase =\n    createAbstraction<IUpdateDashboardUseCase>(\"UpdateDashboardUseCase\");\n\nexport namespace UpdateDashboardUseCase {\n    export type Interface = IUpdateDashboardUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateDashboardRepository - Writes an owner's dashboard layout to storage.\n */\nexport interface IUpdateDashboardRepository {\n    save(\n        ownerId: string,\n        layout: DashboardLayout\n    ): Promise<Result<DashboardLayout, RepositoryError>>;\n}\n\ntype RepositoryError = DashboardPersistenceError;\n\nexport const UpdateDashboardRepository = createAbstraction<IUpdateDashboardRepository>(\n    \"UpdateDashboardRepository\"\n);\n\nexport namespace UpdateDashboardRepository {\n    export type Interface = IUpdateDashboardRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UpdateDashboardUseCase","createAbstraction","UpdateDashboardRepository"],"mappings":";AAsBO,MAAMA,yBACTC,kBAA2C;AAmBxC,MAAMC,4BAA4BD,kBACrC"}

package/features/UpdateDashboard/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const UpdateDashboardFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/UpdateDashboard/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateDashboardUseCase } from "./UpdateDashboardUseCase.js";
+import { UpdateDashboardRepository } from "./UpdateDashboardRepository.js";
+const UpdateDashboardFeature = createFeature({
+    name: "UpdateDashboard",
+    register (container) {
+        container.register(UpdateDashboardUseCase);
+        container.register(UpdateDashboardRepository).inSingletonScope();
+    }
+});
+export { UpdateDashboardFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/UpdateDashboard/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateDashboard/feature.js","sources":["../../../src/features/UpdateDashboard/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateDashboardUseCase } from \"./UpdateDashboardUseCase.js\";\nimport { UpdateDashboardRepository } from \"./UpdateDashboardRepository.js\";\n\nexport const UpdateDashboardFeature = createFeature({\n    name: \"UpdateDashboard\",\n    register(container) {\n        container.register(UpdateDashboardUseCase);\n        container.register(UpdateDashboardRepository).inSingletonScope();\n    }\n});\n"],"names":["UpdateDashboardFeature","createFeature","container","UpdateDashboardUseCase","UpdateDashboardRepository"],"mappings":";;;AAIO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,2BAA2B,gBAAgB;IAClE;AACJ"}

package/features/UpdateDashboard/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { UpdateDashboardFeature } from "./feature.js";

package/features/UpdateDashboard/index.js

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { UpdateDashboardFeature } from "./feature.js";

package/features/UpdateDashboard/schema.d.ts

@@ -0,0 +1,6 @@
+import zod from "zod";
+export declare const updateDashboardValidation: zod.ZodObject<{
+    columns: zod.ZodArray<zod.ZodArray<zod.ZodString>>;
+    hidden: zod.ZodArray<zod.ZodString>;
+    columnCount: zod.ZodNumber;
+}, zod.core.$strip>;

package/features/UpdateDashboard/schema.js

@@ -0,0 +1,10 @@
+import zod from "zod";
+const widgetName = zod.string().min(1).max(200);
+const updateDashboardValidation = zod.object({
+    columns: zod.array(zod.array(widgetName).max(100)).max(4),
+    hidden: zod.array(widgetName).max(200),
+    columnCount: zod.number().int().min(2).max(4)
+});
+export { updateDashboardValidation };
+
+//# sourceMappingURL=schema.js.map

package/features/UpdateDashboard/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateDashboard/schema.js","sources":["../../../src/features/UpdateDashboard/schema.ts"],"sourcesContent":["import zod from \"zod\";\n\nconst widgetName = zod.string().min(1).max(200);\n\n// Bounds match the admin dashboard (2 to 4 columns), and keep the stored entry small.\nexport const updateDashboardValidation = zod.object({\n    columns: zod.array(zod.array(widgetName).max(100)).max(4),\n    hidden: zod.array(widgetName).max(200),\n    columnCount: zod.number().int().min(2).max(4)\n});\n"],"names":["widgetName","zod","updateDashboardValidation"],"mappings":";AAEA,MAAMA,aAAaC,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AAGpC,MAAMC,4BAA4BD,IAAI,MAAM,CAAC;IAChD,SAASA,IAAI,KAAK,CAACA,IAAI,KAAK,CAACD,YAAY,GAAG,CAAC,MAAM,GAAG,CAAC;IACvD,QAAQC,IAAI,KAAK,CAACD,YAAY,GAAG,CAAC;IAClC,aAAaC,IAAI,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AAC/C"}

package/graphql/DashboardGraphQLSchema.d.ts

@@ -0,0 +1,10 @@
+import { CoreGraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { GraphQLSchemaBuilder } from "@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js";
+declare class DashboardGraphQLSchemaImpl implements CoreGraphQLSchemaFactory.Interface {
+    getSchemaKey: () => string;
+    execute(builder: GraphQLSchemaBuilder.Interface): CoreGraphQLSchemaFactory.Return;
+}
+export declare const DashboardGraphQLSchema: typeof DashboardGraphQLSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.core").ICoreGraphQLSchemaFactory>;
+};
+export {};

package/graphql/DashboardGraphQLSchema.js

@@ -0,0 +1,105 @@
+import { resolve } from "@webiny/api-graphql";
+import { staticSchemaKey } from "@webiny/api-graphql/graphql/staticSchemaKey.js";
+import { CoreGraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { ListDashboardsUseCase } from "../features/ListDashboards/abstractions.js";
+import { UpdateDashboardUseCase } from "../features/UpdateDashboard/abstractions.js";
+const TYPE_DEFS = `
+    type Dashboard {
+        columns: [[String!]!]!
+        hidden: [String!]!
+        columnCount: Int!
+    }
+
+    input DashboardInput {
+        columns: [[String!]!]!
+        hidden: [String!]!
+        columnCount: Int!
+    }
+
+    type DashboardError {
+        code: String
+        message: String!
+        data: JSON
+        stack: String
+    }
+
+    type DashboardResponse {
+        data: Dashboard
+        error: DashboardError
+    }
+
+    type DashboardListResponse {
+        data: [Dashboard!]
+        error: DashboardError
+    }
+
+    type DashboardQuery {
+        # The current identity's dashboards: empty until it customizes one, at most one for now.
+        listDashboards: DashboardListResponse!
+    }
+
+    type DashboardMutation {
+        # Creates the identity's dashboard on first use.
+        updateDashboard(data: DashboardInput!): DashboardResponse!
+    }
+
+    extend type Query {
+        dashboard: DashboardQuery
+    }
+
+    extend type Mutation {
+        dashboard: DashboardMutation
+    }
+`;
+class DashboardGraphQLSchemaImpl {
+    async execute(builder) {
+        builder.addTypeDefs(TYPE_DEFS);
+        builder.addResolver({
+            path: "Query.dashboard",
+            dependencies: [],
+            resolver: ()=>()=>({})
+        });
+        builder.addResolver({
+            path: "Mutation.dashboard",
+            dependencies: [],
+            resolver: ()=>()=>({})
+        });
+        builder.addResolver({
+            path: "DashboardQuery.listDashboards",
+            dependencies: [
+                ListDashboardsUseCase
+            ],
+            resolver (listDashboards) {
+                return async ()=>resolve(async ()=>{
+                        const result = await listDashboards.execute();
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+            }
+        });
+        builder.addResolver({
+            path: "DashboardMutation.updateDashboard",
+            dependencies: [
+                UpdateDashboardUseCase
+            ],
+            resolver (updateDashboard) {
+                return async ({ args })=>resolve(async ()=>{
+                        const result = await updateDashboard.execute(args.data);
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+            }
+        });
+        return builder;
+    }
+    constructor(){
+        this.getSchemaKey = staticSchemaKey("api-dashboard/DashboardGraphQLSchemaImpl");
+    }
+}
+const DashboardGraphQLSchema = CoreGraphQLSchemaFactory.createImplementation({
+    implementation: DashboardGraphQLSchemaImpl,
+    dependencies: []
+});
+export { DashboardGraphQLSchema };
+
+//# sourceMappingURL=DashboardGraphQLSchema.js.map

package/graphql/DashboardGraphQLSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/DashboardGraphQLSchema.js","sources":["../../src/graphql/DashboardGraphQLSchema.ts"],"sourcesContent":["import { resolve } from \"@webiny/api-graphql\";\nimport { staticSchemaKey } from \"@webiny/api-graphql/graphql/staticSchemaKey.js\";\nimport { CoreGraphQLSchemaFactory } from \"@webiny/api-graphql/graphql/abstractions.js\";\nimport { GraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\nimport { ListDashboardsUseCase } from \"~/features/ListDashboards/abstractions.js\";\nimport { UpdateDashboardUseCase } from \"~/features/UpdateDashboard/abstractions.js\";\nimport type { DashboardLayout } from \"~/domain/types.js\";\n\nconst TYPE_DEFS = /* GraphQL */ `\n    type Dashboard {\n        columns: [[String!]!]!\n        hidden: [String!]!\n        columnCount: Int!\n    }\n\n    input DashboardInput {\n        columns: [[String!]!]!\n        hidden: [String!]!\n        columnCount: Int!\n    }\n\n    type DashboardError {\n        code: String\n        message: String!\n        data: JSON\n        stack: String\n    }\n\n    type DashboardResponse {\n        data: Dashboard\n        error: DashboardError\n    }\n\n    type DashboardListResponse {\n        data: [Dashboard!]\n        error: DashboardError\n    }\n\n    type DashboardQuery {\n        # The current identity's dashboards: empty until it customizes one, at most one for now.\n        listDashboards: DashboardListResponse!\n    }\n\n    type DashboardMutation {\n        # Creates the identity's dashboard on first use.\n        updateDashboard(data: DashboardInput!): DashboardResponse!\n    }\n\n    extend type Query {\n        dashboard: DashboardQuery\n    }\n\n    extend type Mutation {\n        dashboard: DashboardMutation\n    }\n`;\n\nclass DashboardGraphQLSchemaImpl implements CoreGraphQLSchemaFactory.Interface {\n    public getSchemaKey = staticSchemaKey(\"api-dashboard/DashboardGraphQLSchemaImpl\");\n\n    public async execute(builder: GraphQLSchemaBuilder.Interface): CoreGraphQLSchemaFactory.Return {\n        builder.addTypeDefs(TYPE_DEFS);\n\n        builder.addResolver({\n            path: \"Query.dashboard\",\n            dependencies: [],\n            resolver: () => () => ({})\n        });\n\n        builder.addResolver({\n            path: \"Mutation.dashboard\",\n            dependencies: [],\n            resolver: () => () => ({})\n        });\n\n        builder.addResolver({\n            path: \"DashboardQuery.listDashboards\",\n            dependencies: [ListDashboardsUseCase],\n            resolver(listDashboards: ListDashboardsUseCase.Interface) {\n                return async () => {\n                    return resolve(async () => {\n                        const result = await listDashboards.execute();\n                        if (result.isFail()) {\n                            throw result.error;\n                        }\n                        return result.value;\n                    });\n                };\n            }\n        });\n\n        builder.addResolver<{ data: DashboardLayout }>({\n            path: \"DashboardMutation.updateDashboard\",\n            dependencies: [UpdateDashboardUseCase],\n            resolver(updateDashboard: UpdateDashboardUseCase.Interface) {\n                return async ({ args }) => {\n                    return resolve(async () => {\n                        const result = await updateDashboard.execute(args.data);\n                        if (result.isFail()) {\n                            throw result.error;\n                        }\n                        return result.value;\n                    });\n                };\n            }\n        });\n\n        return builder;\n    }\n}\n\nexport const DashboardGraphQLSchema = CoreGraphQLSchemaFactory.createImplementation({\n    implementation: DashboardGraphQLSchemaImpl,\n    dependencies: []\n});\n"],"names":["TYPE_DEFS","DashboardGraphQLSchemaImpl","builder","ListDashboardsUseCase","listDashboards","resolve","result","UpdateDashboardUseCase","updateDashboard","args","staticSchemaKey","DashboardGraphQLSchema","CoreGraphQLSchemaFactory"],"mappings":";;;;;AAQA,MAAMA,YAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CjC,CAAC;AAED,MAAMC;IAGF,MAAa,QAAQC,OAAuC,EAAmC;QAC3FA,QAAQ,WAAW,CAACF;QAEpBE,QAAQ,WAAW,CAAC;YAChB,MAAM;YACN,cAAc,EAAE;YAChB,UAAU,IAAM,IAAO,EAAC;QAC5B;QAEAA,QAAQ,WAAW,CAAC;YAChB,MAAM;YACN,cAAc,EAAE;YAChB,UAAU,IAAM,IAAO,EAAC;QAC5B;QAEAA,QAAQ,WAAW,CAAC;YAChB,MAAM;YACN,cAAc;gBAACC;aAAsB;YACrC,UAASC,cAA+C;gBACpD,OAAO,UACIC,QAAQ;wBACX,MAAMC,SAAS,MAAMF,eAAe,OAAO;wBAC3C,IAAIE,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;wBAEtB,OAAOA,OAAO,KAAK;oBACvB;YAER;QACJ;QAEAJ,QAAQ,WAAW,CAA4B;YAC3C,MAAM;YACN,cAAc;gBAACK;aAAuB;YACtC,UAASC,eAAiD;gBACtD,OAAO,OAAO,EAAEC,IAAI,EAAE,GACXJ,QAAQ;wBACX,MAAMC,SAAS,MAAME,gBAAgB,OAAO,CAACC,KAAK,IAAI;wBACtD,IAAIH,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;wBAEtB,OAAOA,OAAO,KAAK;oBACvB;YAER;QACJ;QAEA,OAAOJ;IACX;;aAlDO,YAAY,GAAGQ,gBAAgB;;AAmD1C;AAEO,MAAMC,yBAAyBC,yBAAyB,oBAAoB,CAAC;IAChF,gBAAgBX;IAChB,cAAc,EAAE;AACpB"}

package/index.d.ts

@@ -0,0 +1,2 @@
+export { DashboardAppFeature } from "./DashboardAppFeature.js";
+export type { DashboardLayout } from "./domain/types.js";

package/index.js

@@ -0,0 +1 @@
+export { DashboardAppFeature } from "./DashboardAppFeature.js";

package/package.json

@@ -1,6 +1,36 @@
 {
-  "name": "@webiny/api-dashboard",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@webiny/api-dashboard",
+	"version": "0.0.0-unstable.7c2def32a7",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "Stores each admin user's dashboard layout.",
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api-core": "0.0.0-unstable.7c2def32a7",
+		"@webiny/api-graphql": "0.0.0-unstable.7c2def32a7",
+		"@webiny/feature": "0.0.0-unstable.7c2def32a7",
+		"zod": "4.4.3"
+	},
+	"devDependencies": {
+		"@webiny/api-core-testing": "0.0.0-unstable.7c2def32a7",
+		"@webiny/build-tools": "0.0.0-unstable.7c2def32a7",
+		"@webiny/event-handler-core": "0.0.0-unstable.7c2def32a7",
+		"graphql": "16.14.2",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.11"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}