@squidcloud/backend 1.0.9 → 1.0.11

package/dist/backend/src/actions.d.ts

@@ -0,0 +1,13 @@
+import { ActionMethodDecorator, ActionType, ApiEndpointId, CollectionName, CronExpression, CronExpressionString, ExecutableAction, IntegrationId, QueryName, SchedulerAction, SchedulerId, SecureApiAction, SecureDatabaseAction, SecureExecutableAction, SecureGraphQLAction, SecureNamedQueryAction, TransformDatabaseAction, TriggerAction, TriggerId, WebhookAction, WebhookId } from '@squidcloud/common';
+export declare function secureDatabase<T extends ActionType>(type: T, integrationId?: IntegrationId): ActionMethodDecorator<SecureDatabaseAction<T>>;
+export declare function secureCollection<T extends ActionType>(collectionName: CollectionName, type: T, integrationId?: IntegrationId): ActionMethodDecorator<SecureDatabaseAction<T>>;
+export declare function secureExecutable(executable: string): ActionMethodDecorator<SecureExecutableAction>;
+export declare function secureApi<T extends SecureApiAction>(integrationId: IntegrationId, endpointId?: ApiEndpointId): ActionMethodDecorator<SecureApiAction>;
+export declare function secureGraphQL<T extends SecureGraphQLAction>(integrationId: IntegrationId): ActionMethodDecorator<SecureGraphQLAction>;
+export declare function transformCollection<T extends ActionType>(collectionName: CollectionName, type: T, integrationId?: IntegrationId): ActionMethodDecorator<TransformDatabaseAction<T>>;
+export declare function executable(): ActionMethodDecorator<ExecutableAction>;
+export declare function trigger(id: TriggerId, collectionName: CollectionName, integrationId?: IntegrationId): ActionMethodDecorator<TriggerAction>;
+export declare function scheduler(id: SchedulerId, cronExpression: CronExpression | CronExpressionString): ActionMethodDecorator<SchedulerAction>;
+export declare function webhook(id: WebhookId): ActionMethodDecorator<WebhookAction>;
+export declare function namedQuery(integrationId: string, name: string): any;
+export declare function secureNamedQuery<T extends SecureNamedQueryAction>(integrationId: IntegrationId, queryName: QueryName): ActionMethodDecorator<SecureNamedQueryAction>;

package/dist/backend/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './actions';
+export * from './project';
+export * from './service';

package/dist/backend/src/metadata.d.ts

@@ -0,0 +1,234 @@
+import { ActionType, ApiEndpointId, ApplicationBundleData, CollectionName, FunctionName, IntegrationId, QueryName, SchedulerId, ServiceFunctionName, TriggerId, WebhookId } from '@squidcloud/common';
+declare class Meta {
+    data: ApplicationBundleData;
+    /**
+     * @secureDatabase("read", "ExampleIntegration")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   databases: {
+     *     ExampleIntegration: {
+     *       security: {
+     *         read: ['MyService:myMethod']
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    secureDatabase(type: ActionType, serviceFunction: ServiceFunctionName, integrationId?: IntegrationId): void;
+    /**
+     * @secureCollection("ExampleCollection", "read", "ExampleIntegration")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   databases: {
+     *     ExampleIntegration: {
+     *       collections: {
+     *         ExampleCollection: {
+     *           security: {
+     *             read: ['MyService:myMethod']
+     *           }
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    secureCollection(collectionName: CollectionName, type: ActionType, serviceFunction: ServiceFunctionName, integrationId?: IntegrationId): void;
+    /**
+     * @secureExecutable("myExecutable")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   executables: {
+     *     myExecutable: {
+     *       security: ['MyService:myMethod']
+     *     }
+     *   }
+     * }
+     */
+    secureExecutable(executable: FunctionName, serviceFunction: ServiceFunctionName): void;
+    /**
+     * @secureApi("ExampleIntegration", "myEndpoint")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   apis: {
+     *     ExampleIntegration: {
+     *       myEndpoint: {
+     *         security: ['MyService:myMethod']
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    secureApi(integrationId: IntegrationId, endpointId: ApiEndpointId | undefined, serviceFunction: ServiceFunctionName): void;
+    /**
+     * @secureGraphQL("ExampleIntegration")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   graphql: {
+     *     ExampleIntegration: {
+     *       security: ['MyService:myMethod']
+     *     }
+     *   }
+     * }
+     */
+    secureGraphQL(integrationId: IntegrationId, serviceFunction: ServiceFunctionName): void;
+    /**
+     * @transformDatabase(""read", "ExampleIntegration")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   databases: {
+     *     ExampleIntegration: {
+     *       transform: {
+     *         read: {
+     *           type: "read"
+     *           functionName: "MyService:myMethod"
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    transformDatabase(type: ActionType, serviceFunction: ServiceFunctionName, integrationId?: IntegrationId): void;
+    /**
+     * @transformCollection("ExampleCollection", "read", "ExampleIntegration")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   databases: {
+     *     ExampleIntegration: {
+     *       collections: {
+     *         ExampleCollection: {
+     *           transform: {
+     *             read: {
+     *               type: "read"
+     *               functionName: "MyService:myMethod"
+     *             }
+     *           }
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    transformCollection(collectionName: CollectionName, type: ActionType, serviceFunction: ServiceFunctionName, integrationId?: IntegrationId): void;
+    /**
+     * @executable()
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   executables: {
+     *     myExecutable: {
+     *       serviceName: "MyService:myMethod",
+     *     }
+     *   }
+     * }
+     */
+    executable(serviceFunction: ServiceFunctionName): void;
+    /**
+     * @trigger("my-trigger", "ExampleCollection", "ExampleIntegration")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   triggers: {
+     *     "my-trigger": {
+     *       integrationId: "ExampleIntegration"
+     *       collectionName: "ExampleCollection"
+     *       functionName: "MyService:myMethod",
+     *     }
+     *   }
+     * }
+     */
+    trigger(id: TriggerId, collectionName: CollectionName, serviceFunction: ServiceFunctionName, integrationId?: IntegrationId): void;
+    /**
+     * @scheduler("my-scheduler", "CronExpression")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   schedulers: {
+     *     "my-scheduler", {
+     *       cronExpression: "CronExpression"
+     *       functionName: "MyService:myMethod",
+     *     }
+     *   }
+     * }
+     */
+    scheduler(id: SchedulerId, cronExpression: string, serviceFunction: ServiceFunctionName): void;
+    /**
+     * @webhook("my-webhook")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   webhooks: {
+     *     "my-webhook", {
+     *       functionName: "MyService:myMethod",
+     *     }
+     *   }
+     * }
+     */
+    webhook(id: WebhookId, serviceFunction: ServiceFunctionName): void;
+    /**
+     * @namedQuery('exampleIntegration', 'my-query')
+     * static  myQuery = "select * from my-table where id = ${id}";
+     *
+     * Applying the decorator above to the myQuery static string in MyService
+     * class will generate the following metadata:
+     *
+     *
+     *
+     * data: {
+     *   namedQueries: {
+     *     "exampleIntegration", {
+     *       my-query: {
+     *         queryString: "select * from my-table where id = $id"
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    namedQuery(integrationId: IntegrationId, name: QueryName, queryString: string): void;
+    /**
+     * @secureNamedQuery("exampleIntegration", "queryName")
+     *
+     * Applying the decorator above to the myMethod method on the MyService
+     * class will generate the following metadata:
+     *
+     * data: {
+     *   namedQueries: {
+     *     exampleIntegration: {
+     *     queryName: {
+     *       security: MyService:myMethod
+     *     }
+     *   }
+     * }
+     */
+    secureNamedQuery(integrationId: IntegrationId, name: QueryName, serviceFunction: ServiceFunctionName): void;
+}
+export declare const metadata: Meta;
+export {};

package/dist/backend/src/project.d.ts

@@ -0,0 +1,4 @@
+export declare class SquidProject {
+    private metadata;
+    private cleanup;
+}

package/dist/backend/src/service.d.ts

@@ -0,0 +1,18 @@
+import { Squid } from '@squidcloud/client';
+import { AuthWithApiKey, AuthWithBearer, Logger, RunContext, SecretKey, SecretValue, ServiceConfig, SupportedSquidRegion, WebhookResponse } from '@squidcloud/common';
+export declare class SquidService {
+    readonly secrets: Record<SecretKey, SecretValue>;
+    readonly logger: Logger;
+    private readonly backendApiKey;
+    readonly context: RunContext;
+    readonly codeDir: string;
+    readonly region: SupportedSquidRegion;
+    private readonly auth;
+    constructor(config: ServiceConfig);
+    get squid(): Squid;
+    get assetsDirectory(): string;
+    getUserAuth(): AuthWithBearer | undefined;
+    getApiKeyAuth(): AuthWithApiKey | undefined;
+    isAuthenticated(): boolean;
+    createWebhookResponse(body?: any, statusCode?: number, headers?: Record<string, any>): WebhookResponse;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/backend",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Squid Cloud's backend SDK",
   "main": "dist/index.js",
   "types": "dist/backend/src/index.d.ts",
@@ -10,7 +10,8 @@
     "publish:public": "npm version patch && npm run build && npm publish --access public"
   },
   "files": [
-    "dist/index.js"
+    "dist/index.js",
+    "dist/backend"
   ],
   "keywords": [],
   "author": "",