@seliseblocks/client 0.1.0-beta.2 → 0.1.1

package/dist/data/data-client.d.ts

@@ -1,5 +1,5 @@
 import { BlocksHttpClient } from "../http/http-client.js";
-import { BlocksDataCollection, BlocksDmsCreateFolderRequest, BlocksDmsListRequest, BlocksDmsUploadRequest, BlocksFileDeleteRequest, BlocksFileGetOptions, BlocksFileInfoListRequest, BlocksDataSchema, BlocksFileListRequest, BlocksFileUpdateAdditionalInfoRequest, BlocksFileUploadRequest, BlocksFolderDeleteRequest, BlocksGraphqlRequest, BlocksLocalStorageUploadRequest, BlocksPagedResult, BlocksRegexGenerateRequest, BlocksSchemaFieldValidationOptions, BlocksSchemaListOptions, BlocksSchemaValidationListOptions, BlocksUploadToUrlRequest } from "./types.js";
+import { BlocksDataCollection, BlocksDataCollectionOptions, BlocksDmsCreateFolderRequest, BlocksDmsListRequest, BlocksDmsUploadRequest, BlocksFileDeleteRequest, BlocksFileGetOptions, BlocksFileInfoListRequest, BlocksDataSchema, BlocksFileListRequest, BlocksFileUpdateAdditionalInfoRequest, BlocksFileUploadRequest, BlocksFolderDeleteRequest, BlocksGraphqlRequest, BlocksLocalStorageUploadRequest, BlocksPagedResult, BlocksRegexGenerateRequest, BlocksSchemaFieldValidationOptions, BlocksSchemaListOptions, BlocksSchemaValidationListOptions, BlocksUploadToUrlRequest } from "./types.js";
 export declare class BlocksDataClient {
     private readonly http;
     constructor(http: BlocksHttpClient);
@@ -171,8 +171,8 @@ export declare class BlocksDataClient {
     };
     /**
      * What: creates CRUD helpers for a Data runtime collection.
-     * Why: frontend code usually works with business collection names rather than hand-written URLs.
-     * How: pass the exact collection name; returned helpers support list/get/create/update/delete and never add `ProjectKey`.
+     * Why: frontend code usually works with schema names rather than hand-written GraphQL operations.
+     * How: pass the exact schema name, such as `Product`; returned helpers call `/data/v4/gateway` and never add `ProjectKey`.
      */
-    collection<T = Record<string, unknown>>(name: string): BlocksDataCollection<T>;
+    collection<T = Record<string, unknown>>(schemaName: string, options?: BlocksDataCollectionOptions): BlocksDataCollection<T>;
 }

package/dist/data/data-client.js

@@ -241,51 +241,100 @@ export class BlocksDataClient {
     };
     /**
      * What: creates CRUD helpers for a Data runtime collection.
-     * Why: frontend code usually works with business collection names rather than hand-written URLs.
-     * How: pass the exact collection name; returned helpers support list/get/create/update/delete and never add `ProjectKey`.
+     * Why: frontend code usually works with schema names rather than hand-written GraphQL operations.
+     * How: pass the exact schema name, such as `Product`; returned helpers call `/data/v4/gateway` and never add `ProjectKey`.
      */
-    collection(name) {
+    collection(schemaName, options = {}) {
+        assertGraphqlName(schemaName, "schemaName");
+        const listField = `get${schemaName}s`;
+        const createField = `insert${schemaName}`;
+        const updateField = `update${schemaName}`;
+        const deleteField = `delete${schemaName}`;
         return {
             /**
-             * What: creates a collection item through `POST /data/v4/{collection}`.
+             * What: creates a schema-backed item through `POST /data/v4/gateway`.
              * Why: forms need a direct runtime create operation.
-             * How: pass the item payload; Data validates it against the active collection schema.
+             * How: pass the item payload; Data validates it against the active schema's insert input.
              */
-            create: (payload) => this.http.request(`${DATA_API}/${encodeURIComponent(name)}`, { body: payload }),
+            create: (payload) => this.graphql({
+                operationName: createField,
+                query: `mutation ${createField}($input: ${schemaName}InsertInput!) {
+  ${createField}(input: $input) {
+    acknowledged
+    itemId
+    message
+    totalImpactedData
+  }
+}`,
+                variables: { input: payload }
+            }),
             /**
-             * What: deletes a collection item through `DELETE /data/v4/{collection}/{itemId}`.
+             * What: deletes a schema-backed item through `POST /data/v4/gateway`.
              * Why: collection UIs need a runtime delete operation when allowed by permissions/rules.
-             * How: pass the item id from Data.
+             * How: pass the item id from Data; the SDK sends a GraphQL `filter` on `ItemId`.
              */
-            delete: (itemId) => this.http.request(`${DATA_API}/${encodeURIComponent(name)}/${encodeURIComponent(itemId)}`, {
-                method: "DELETE"
+            delete: (itemId, deleteOptions = {}) => this.graphql({
+                operationName: deleteField,
+                query: `mutation ${deleteField}($filter: String, $input: ${schemaName}DeleteInput!) {
+  ${deleteField}(filter: $filter, input: $input) {
+    acknowledged
+    itemId
+    message
+    totalImpactedData
+  }
+}`,
+                variables: {
+                    filter: itemIdFilter(itemId),
+                    input: { isHardDelete: deleteOptions.hardDelete ?? false }
+                }
             }),
             /**
-             * What: reads one collection item through `GET /data/v4/{collection}/{itemId}`.
+             * What: reads one schema-backed item through `POST /data/v4/gateway`.
              * Why: detail pages need one runtime record by id.
-             * How: pass the item id from Data.
+             * How: pass the item id from Data; the SDK queries `get{SchemaName}s` with an `ItemId` filter.
              */
-            get: (itemId) => this.http.request(`${DATA_API}/${encodeURIComponent(name)}/${encodeURIComponent(itemId)}`),
+            get: (itemId, getOptions = {}) => this.graphql({
+                operationName: listField,
+                query: collectionListQuery(listField, selectionFor(getOptions.fields ?? options.fields)),
+                variables: {
+                    input: {
+                        filter: itemIdFilter(itemId),
+                        pageNo: 1,
+                        pageSize: 1
+                    }
+                }
+            }),
             /**
-             * What: lists collection items through `GET /data/v4/{collection}`.
+             * What: lists schema-backed items through `POST /data/v4/gateway`.
              * Why: tables, grids, and pickers need paged runtime records.
-             * How: pass `pageNo`, `pageSize`, and optional query fields supported by the collection endpoint.
+             * How: pass `pageNo`, `pageSize`, optional `filter`/`sort`, and GraphQL fields to select.
              */
-            list: (options) => this.http.request(`${DATA_API}/${encodeURIComponent(name)}`, {
-                query: {
-                    PageNo: options?.pageNo ?? 1,
-                    PageSize: options?.pageSize ?? 20,
-                    ...options?.query
+            list: (listOptions) => this.graphql({
+                operationName: listField,
+                query: collectionListQuery(listField, selectionFor(listOptions?.fields ?? options.fields)),
+                variables: {
+                    input: dynamicQueryInput(listOptions)
                 }
             }),
             /**
-             * What: updates a collection item through `PUT /data/v4/{collection}/{itemId}`.
+             * What: updates a schema-backed item through `POST /data/v4/gateway`.
              * Why: edit forms need a runtime update operation.
-             * How: pass the item id and partial payload; Data applies its schema/rule validation.
+             * How: pass the item id and partial payload; the SDK sends a GraphQL `filter` on `ItemId`.
              */
-            update: (itemId, payload) => this.http.request(`${DATA_API}/${encodeURIComponent(name)}/${encodeURIComponent(itemId)}`, {
-                body: payload,
-                method: "PUT"
+            update: (itemId, payload) => this.graphql({
+                operationName: updateField,
+                query: `mutation ${updateField}($filter: String, $input: ${schemaName}UpdateInput!) {
+  ${updateField}(filter: $filter, input: $input) {
+    acknowledged
+    itemId
+    message
+    totalImpactedData
+  }
+}`,
+                variables: {
+                    filter: itemIdFilter(itemId),
+                    input: payload
+                }
             })
         };
     }
@@ -383,3 +432,50 @@ function withoutProjectKey(request) {
     delete record.ProjectKey;
     return record;
 }
+function dynamicQueryInput(options) {
+    return {
+        filter: normalizeGraphqlJsonInput(options?.filter ?? options?.query),
+        pageNo: options?.pageNo ?? 1,
+        pageSize: options?.pageSize ?? 20,
+        sort: normalizeGraphqlJsonInput(options?.sort)
+    };
+}
+function collectionListQuery(fieldName, selection) {
+    return `query ${fieldName}($input: DynamicQueryInput) {
+  ${fieldName}(input: $input) {
+    items {
+${indent(selection, 6)}
+    }
+    totalCount
+    pageNo
+    pageSize
+    totalPages
+    hasNextPage
+    hasPreviousPage
+  }
+}`;
+}
+function selectionFor(fields) {
+    const selected = fields?.length ? fields : ["ItemId"];
+    const unique = Array.from(new Set(["ItemId", ...selected]));
+    for (const field of unique)
+        assertGraphqlName(field, "field");
+    return unique.join("\n");
+}
+function itemIdFilter(itemId) {
+    return JSON.stringify({ ItemId: itemId });
+}
+function normalizeGraphqlJsonInput(value) {
+    if (value === undefined)
+        return undefined;
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function assertGraphqlName(value, label) {
+    if (!/^[_A-Za-z][_0-9A-Za-z]*$/.test(value)) {
+        throw new Error(`Invalid Blocks Data GraphQL ${label}: ${value}`);
+    }
+}
+function indent(value, spaces) {
+    const pad = " ".repeat(spaces);
+    return value.split("\n").map((line) => `${pad}${line}`).join("\n");
+}

package/dist/data/types.d.ts

@@ -9,14 +9,30 @@ export type BlocksPagedResult<T> = {
     message?: string | null;
 };
 export type BlocksDataListOptions = {
+    fields?: string[];
+    filter?: Record<string, unknown> | string;
     pageNo?: number;
     pageSize?: number;
+    /**
+     * Legacy convenience alias for the GraphQL DynamicQueryInput.Filter payload.
+     * Prefer `filter` for new code.
+     */
     query?: Record<string, boolean | number | string | undefined>;
+    sort?: Record<string, unknown> | string;
+};
+export type BlocksDataCollectionOptions = {
+    fields?: string[];
+};
+export type BlocksDataDeleteOptions = {
+    hardDelete?: boolean;
+};
+export type BlocksDataGetOptions = {
+    fields?: string[];
 };
 export type BlocksDataCollection<T = Record<string, unknown>> = {
     create(payload: Partial<T>): Promise<unknown>;
-    delete(itemId: string): Promise<unknown>;
-    get(itemId: string): Promise<unknown>;
+    delete(itemId: string, options?: BlocksDataDeleteOptions): Promise<unknown>;
+    get(itemId: string, options?: BlocksDataGetOptions): Promise<unknown>;
     list(options?: BlocksDataListOptions): Promise<unknown>;
     update(itemId: string, payload: Partial<T>): Promise<unknown>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seliseblocks/client",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.1",
   "description": "Framework-neutral TypeScript client SDK for SELISE Blocks frontend applications.",
   "license": "MIT",
   "type": "module",