@awsless/awsless 0.0.246 → 0.0.248

package/dist/chunk-RRXFYZJQ.js

@@ -0,0 +1,61 @@
+// src/lib/resource/util.ts
+import { paramCase } from "change-case";
+var APP = process.env.APP ?? "app";
+var STACK = process.env.STACK ?? "stack";
+var bindLocalResourceName = (type) => {
+  return (name, stack = STACK) => {
+    return [APP, paramCase(stack), paramCase(type), paramCase(name)].join(
+      "--"
+    );
+  };
+};
+var bindGlobalResourceName = (type) => {
+  return (name) => {
+    return [APP, paramCase(type), paramCase(name)].join("--");
+  };
+};
+var createProxy = /* @__NO_SIDE_EFFECTS__ */ (cb) => {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(
+    {},
+    {
+      get(_, name) {
+        if (!cache.has(name)) {
+          cache.set(name, cb(name));
+        }
+        return cache.get(name);
+      }
+    }
+  );
+};
+
+// src/lib/resource/auth.ts
+import { constantCase } from "change-case";
+var getAuthName = bindGlobalResourceName("auth");
+var Auth = /* @__PURE__ */ createProxy((name) => {
+  return getAuthProps(name);
+});
+var getAuthProps = (name) => {
+  const env = process.env;
+  const id = constantCase(name);
+  return {
+    name: getAuthName(name),
+    // userPoolId: env[`AWSLESS_CLIENT_AUTH_${id}_USER_POOL_ID`]!,
+    // clientId: env[`AWSLESS_CLIENT_AUTH_${id}_CLIENT_ID`]!,
+    // clientSecret: env[`AWSLESS_CLIENT_AUTH_${id}_CLIENT_SECRET`]!,
+    userPoolId: env[`AUTH_${id}_USER_POOL_ID`],
+    clientId: env[`AUTH_${id}_CLIENT_ID`]
+    // clientSecret: env[`AUTH_${id}_CLIENT_SECRET`]!,
+  };
+};
+
+export {
+  APP,
+  STACK,
+  bindLocalResourceName,
+  bindGlobalResourceName,
+  createProxy,
+  getAuthName,
+  Auth,
+  getAuthProps
+};

package/dist/client.d.ts

@@ -1,3 +1,5 @@
+export { A as Auth } from './auth-b89f6013.js';
+
 interface HTTP {
 }
 type Method = 'GET' | 'POST';

package/dist/client.js

@@ -0,0 +1,51 @@
+import {
+  Auth
+} from "./chunk-RRXFYZJQ.js";
+
+// src/lib/resource/http.ts
+var createHttpFetcher = (host) => {
+  return async ({ method, path, headers, body, query }) => {
+    const url = new URL(host, path);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    headers.set("content-type", "application/json");
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const result = await response.json();
+    return result;
+  };
+};
+var createHttpClient = (fetcher) => {
+  const fetch2 = (method, routeKey, props) => {
+    const path = routeKey.replaceAll(/{([a-z0-1-]+)}/, (key) => {
+      return props?.params?.[key.substring(1, key.length - 1)]?.toString() ?? "";
+    });
+    return fetcher({
+      headers: new Headers(props?.headers),
+      query: props?.query,
+      body: props?.body,
+      method,
+      path
+    });
+  };
+  return {
+    fetch: fetch2,
+    get(routeKey, props) {
+      return fetch2("GET", routeKey, props);
+    },
+    post(routeKey, props) {
+      return fetch2("POST", routeKey, props);
+    }
+  };
+};
+export {
+  Auth,
+  createHttpClient,
+  createHttpFetcher
+};

package/dist/server.d.ts

@@ -1,3 +1,4 @@
+export { A as Auth, b as AuthResources, g as getAuthName, a as getAuthProps } from './auth-b89f6013.js';
 import * as _awsless_lambda from '@awsless/lambda';
 import { Handler, Loggers } from '@awsless/lambda';
 import { BaseSchema, SnsTopicSchema, SqsQueueSchema } from '@awsless/validate';
@@ -17,17 +18,6 @@ interface TaskResources {
 }
 declare const Task: TaskResources;
 
-declare const getAuthName: <N extends string>(name: N) => `app--auth--${N}`;
-interface AuthResources {
-}
-declare const Auth: AuthResources;
-declare const getAuthProps: (name: string) => {
-    readonly name: `app--auth--${string}`;
-    readonly userPoolId: string;
-    readonly clientId: string;
-    readonly clientSecret: string;
-};
-
 declare const getTableName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--table--${N}`;
 interface TableResources {
 }
@@ -129,4 +119,4 @@ interface TaskMockResponse {
 }
 declare const mockTask: (cb: (mock: TaskMock) => void) => TaskMockResponse;
 
-export { APP, Auth, AuthResources, Cache, CacheResources, Config, ConfigResources, CronProps, Fn, Function, FunctionMock, FunctionMockResponse, FunctionProps, FunctionResources, Queue, QueueMock, QueueMockResponse, QueueProps, QueueResources, STACK, Search, SearchResources, Store, StoreResources, Table, TableResources, Task, TaskMock, TaskMockResponse, TaskResources, Topic, TopicMock, TopicMockResponse, TopicProps, TopicResources, cron, func, getAuthName, getAuthProps, getCacheProps, getConfigName, getFunctionName, getQueueName, getSearchName, getStoreName, getTableName, getTaskName, getTopicName, mockFunction, mockQueue, mockTask, mockTopic, queue, topic };
+export { APP, Cache, CacheResources, Config, ConfigResources, CronProps, Fn, Function, FunctionMock, FunctionMockResponse, FunctionProps, FunctionResources, Queue, QueueMock, QueueMockResponse, QueueProps, QueueResources, STACK, Search, SearchResources, Store, StoreResources, Table, TableResources, Task, TaskMock, TaskMockResponse, TaskResources, Topic, TopicMock, TopicMockResponse, TopicProps, TopicResources, cron, func, getCacheProps, getConfigName, getFunctionName, getQueueName, getSearchName, getStoreName, getTableName, getTaskName, getTopicName, mockFunction, mockQueue, mockTask, mockTopic, queue, topic };

package/dist/server.js

@@ -0,0 +1,421 @@
+import {
+  APP,
+  Auth,
+  STACK,
+  bindGlobalResourceName,
+  bindLocalResourceName,
+  createProxy,
+  getAuthName,
+  getAuthProps
+} from "./chunk-RRXFYZJQ.js";
+
+// src/lib/resource/function.ts
+import { invoke } from "@awsless/lambda";
+import { WeakCache } from "@awsless/weak-cache";
+var cache = new WeakCache();
+var getFunctionName = bindLocalResourceName("function");
+var Function = /* @__PURE__ */ createProxy((stackName) => {
+  return createProxy((funcName) => {
+    const name = getFunctionName(funcName, stackName);
+    const ctx = {
+      [name]: (payload, options = {}) => {
+        return invoke({
+          ...options,
+          name,
+          payload
+        });
+      }
+    };
+    const call = ctx[name];
+    call.cached = async (payload, options = {}) => {
+      const cacheKey = JSON.stringify({ name, payload, options });
+      if (!cache.has(cacheKey)) {
+        const result = await invoke({
+          ...options,
+          name,
+          payload
+        });
+        cache.set(cacheKey, result);
+      }
+      return cache.get(cacheKey);
+    };
+    return call;
+  });
+});
+var Fn = Function;
+
+// src/lib/resource/task.ts
+import { invoke as invoke2 } from "@awsless/lambda";
+var getTaskName = bindLocalResourceName("task");
+var Task = /* @__PURE__ */ createProxy((stackName) => {
+  return createProxy((taskName) => {
+    const name = getTaskName(taskName, stackName);
+    const ctx = {
+      [name]: (payload, options = {}) => {
+        return invoke2({
+          ...options,
+          type: "Event",
+          name,
+          payload
+        });
+      }
+    };
+    return ctx[name];
+  });
+});
+
+// src/lib/resource/table.ts
+var getTableName = bindLocalResourceName("table");
+var Table = /* @__PURE__ */ createProxy((stack) => {
+  return createProxy((name) => {
+    return getTableName(name, stack);
+  });
+});
+
+// src/lib/resource/topic.ts
+import { publish } from "@awsless/sns";
+var getTopicName = bindGlobalResourceName("topic");
+var Topic = /* @__PURE__ */ createProxy((name) => {
+  const topic2 = getTopicName(name);
+  const ctx = {
+    [topic2]: async (payload, options = {}) => {
+      await publish({
+        ...options,
+        topic: topic2,
+        payload
+      });
+    }
+  };
+  const call = ctx[topic2];
+  return call;
+});
+
+// src/lib/resource/queue.ts
+import {
+  sendMessage,
+  sendMessageBatch
+} from "@awsless/sqs";
+import { constantCase } from "change-case";
+var getQueueName = bindLocalResourceName("queue");
+var getQueueUrl = (name, stack = STACK) => {
+  return process.env[`QUEUE_${constantCase(stack)}_${constantCase(name)}_URL`];
+};
+var Queue = /* @__PURE__ */ createProxy((stack) => {
+  return createProxy((queue2) => {
+    const url = getQueueUrl(queue2, stack);
+    const name = getQueueName(queue2, stack);
+    const ctx = {
+      [name]: (payload, options = {}) => {
+        return sendMessage({
+          ...options,
+          queue: url ?? name,
+          payload
+        });
+      }
+    };
+    const send = ctx[name];
+    send.url = url;
+    send.batch = (items, options = {}) => {
+      return sendMessageBatch({
+        ...options,
+        queue: url ?? name,
+        items
+      });
+    };
+    return send;
+  });
+});
+
+// src/lib/resource/cache.ts
+import { constantCase as constantCase2 } from "change-case";
+import { command } from "@awsless/redis";
+var getCacheProps = (name, stack = STACK) => {
+  const prefix = `CACHE_${constantCase2(stack)}_${constantCase2(name)}`;
+  return {
+    host: process.env[`${prefix}_HOST`],
+    port: parseInt(process.env[`${prefix}_PORT`], 10)
+  };
+};
+var Cache = /* @__PURE__ */ createProxy((stack) => {
+  return createProxy((name) => {
+    const { host, port } = getCacheProps(name, stack);
+    const call = (opts, fn) => {
+      const overload = typeof opts === "function";
+      const options = overload ? {} : opts;
+      const callback = overload ? opts : fn;
+      return command(
+        {
+          host,
+          port,
+          db: 0,
+          cluster: true,
+          ...options
+        },
+        callback
+      );
+    };
+    call.host = host;
+    call.port = port;
+    return call;
+  });
+});
+
+// src/lib/resource/store.ts
+import { putObject, getObject, deleteObject, createPresignedPost } from "@awsless/s3";
+var getStoreName = bindLocalResourceName("store");
+var Store = /* @__PURE__ */ createProxy((stack) => {
+  return createProxy((name) => {
+    const bucket = getStoreName(name, stack);
+    return {
+      name: bucket,
+      async put(key, body, options = {}) {
+        await putObject({
+          bucket,
+          key,
+          body,
+          ...options
+        });
+      },
+      async get(key) {
+        const object = await getObject({ bucket, key });
+        if (object) {
+          return object.body;
+        }
+        return void 0;
+      },
+      delete(key) {
+        return deleteObject({ bucket, key });
+      },
+      createPresignedPost(key, contentLengthRange, expires, fields) {
+        return createPresignedPost({
+          bucket,
+          key,
+          contentLengthRange,
+          expires,
+          fields
+        });
+      }
+    };
+  });
+});
+
+// src/lib/resource/config.ts
+import { ssm } from "@awsless/ssm";
+import { paramCase } from "change-case";
+var getConfigName = (name) => {
+  return `/.awsless/${APP}/${name}`;
+};
+var IS_TEST = process.env.NODE_ENV === "test";
+var CONFIGS = process.env.CONFIG;
+var loadConfigData = /* @__NO_SIDE_EFFECTS__ */ async () => {
+  if (!IS_TEST && CONFIGS) {
+    const keys = CONFIGS.split(",");
+    if (keys.length > 0) {
+      const paths = {};
+      for (const key of keys) {
+        paths[key] = getConfigName(key);
+      }
+      return ssm(paths);
+    }
+  }
+  return {};
+};
+var data = await /* @__PURE__ */ loadConfigData();
+var Config = /* @__PURE__ */ new Proxy(
+  {},
+  {
+    get(_, name) {
+      const key = paramCase(name);
+      const value = data[key];
+      if (typeof value === "undefined") {
+        throw new Error(
+          `The "${name}" config value hasn't been set yet. ${IS_TEST ? `Use "Config.${name} = 'VAlUE'" to define your mock value.` : `Define access to the desired config value inside your awsless stack file.`}`
+        );
+      }
+      return value;
+    },
+    set(_, name, value) {
+      const key = paramCase(name);
+      data[key] = value;
+      return true;
+    }
+  }
+);
+
+// src/lib/resource/search.ts
+import { constantCase as constantCase3 } from "change-case";
+import { searchClient, define } from "@awsless/open-search";
+var getSearchName = bindLocalResourceName("search");
+var getSearchProps = (name, stack = STACK) => {
+  return {
+    domain: process.env[`CACHE_${constantCase3(stack)}_${constantCase3(name)}_DOMAIN`]
+  };
+};
+var Search = /* @__PURE__ */ createProxy((stack) => {
+  return createProxy((name) => {
+    const { domain } = getSearchProps(name, stack);
+    let client;
+    return {
+      domain,
+      defineTable(tableName, schema) {
+        return define(tableName, schema, () => {
+          if (!client)
+            client = searchClient({ node: domain }, "es");
+          return client;
+        });
+      }
+    };
+  });
+});
+
+// src/lib/handle/function.ts
+import { lambda } from "@awsless/lambda";
+var func = (props) => {
+  return lambda(props);
+};
+
+// src/lib/handle/topic.ts
+import { snsTopic } from "@awsless/validate";
+import { lambda as lambda2 } from "@awsless/lambda";
+var topic = (props) => {
+  return lambda2({
+    logger: props.logger,
+    schema: snsTopic(props.schema),
+    handle: props.handle,
+    logViewableErrors: true
+  });
+};
+
+// src/lib/handle/queue.ts
+import { lambda as lambda3 } from "@awsless/lambda";
+import { sqsQueue } from "@awsless/validate";
+var queue = (props) => {
+  return lambda3({
+    logger: props.logger,
+    schema: sqsQueue(props.schema),
+    handle: props.handle,
+    logViewableErrors: true
+  });
+};
+
+// src/lib/handle/cron.ts
+import { lambda as lambda4 } from "@awsless/lambda";
+var cron = (props) => {
+  return lambda4({
+    ...props,
+    logViewableErrors: true
+  });
+};
+
+// src/lib/mock/function.ts
+import { mockLambda } from "@awsless/lambda";
+var mockFunction = (cb) => {
+  const list = {};
+  const mock = createProxy((stack) => {
+    return createProxy((name) => {
+      return (handleOrResponse) => {
+        const handle = typeof handleOrResponse === "function" ? handleOrResponse : () => handleOrResponse;
+        list[getFunctionName(name, stack)] = handle;
+      };
+    });
+  });
+  cb(mock);
+  const result = mockLambda(list);
+  return createProxy((stack) => {
+    return createProxy((name) => {
+      return result[getFunctionName(name, stack)];
+    });
+  });
+};
+
+// src/lib/mock/topic.ts
+import { mockSNS } from "@awsless/sns";
+var mockTopic = (cb) => {
+  const list = {};
+  const mock = createProxy((name) => {
+    return (handle) => {
+      list[getTopicName(name)] = handle ?? (() => {
+      });
+    };
+  });
+  cb(mock);
+  const result = mockSNS(list);
+  return createProxy((name) => {
+    return result[getTopicName(name)];
+  });
+};
+
+// src/lib/mock/queue.ts
+import { mockSQS } from "@awsless/sqs";
+var mockQueue = (cb) => {
+  const list = {};
+  const mock = createProxy((stack) => {
+    return createProxy((name) => {
+      return (handle) => {
+        list[getQueueName(name, stack)] = handle ?? (() => {
+        });
+      };
+    });
+  });
+  cb(mock);
+  const result = mockSQS(list);
+  return createProxy((stack) => {
+    return createProxy((name) => {
+      return result[getQueueName(name, stack)];
+    });
+  });
+};
+
+// src/lib/mock/task.ts
+import { mockLambda as mockLambda2 } from "@awsless/lambda";
+var mockTask = (cb) => {
+  const list = {};
+  const mock = createProxy((stack) => {
+    return createProxy((name) => {
+      return (handle) => {
+        list[getTaskName(name, stack)] = handle;
+      };
+    });
+  });
+  cb(mock);
+  const result = mockLambda2(list);
+  return createProxy((stack) => {
+    return createProxy((name) => {
+      return result[getTaskName(name, stack)];
+    });
+  });
+};
+export {
+  APP,
+  Auth,
+  Cache,
+  Config,
+  Fn,
+  Function,
+  Queue,
+  STACK,
+  Search,
+  Store,
+  Table,
+  Task,
+  Topic,
+  cron,
+  func,
+  getAuthName,
+  getAuthProps,
+  getCacheProps,
+  getConfigName,
+  getFunctionName,
+  getQueueName,
+  getSearchName,
+  getStoreName,
+  getTableName,
+  getTaskName,
+  getTopicName,
+  mockFunction,
+  mockQueue,
+  mockTask,
+  mockTopic,
+  queue,
+  topic
+};