@daocloud-proto/skoala 0.2.0

package/api/general/v1alpha1/version.pb.ts

@@ -0,0 +1,15 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+export type Version = {
+  version?: string
+  gitCommit?: string
+  buildDate?: string
+  goVersion?: string
+}
+
+export type GetVersionRes = {
+  version?: Version
+}

package/api/hive/v1alpha1/book.pb.ts

@@ -0,0 +1,100 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "..\..\..\fetch.pb"
+import * as GoogleProtobufEmpty from "..\..\..\google\protobuf\empty.pb"
+import * as GoogleProtobufTimestamp from "..\..\..\google\protobuf\timestamp.pb"
+
+export enum Status {
+  TAKEDOWN = "TAKEDOWN",
+  ONSHELF = "ONSHELF",
+}
+
+export type GetBookReq = {
+  uid?: string
+}
+
+export type GetBookReply = {
+  uid?: string
+  name?: string
+  author?: string
+  status?: Status
+  isPublished?: boolean
+  publishedAt?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type ListBookReq = {
+  pageNum?: number
+  pageSize?: number
+}
+
+export type ListBookReplyBook = {
+  uid?: string
+  name?: string
+  author?: string
+  status?: Status
+  isPublished?: boolean
+  publishedAt?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type ListBookReply = {
+  results?: ListBookReplyBook[]
+  totalCount?: number
+}
+
+export type CreateBookReq = {
+  name?: string
+  author?: string
+  status?: Status
+  isPublished?: boolean
+  publishedAt?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type CreateBookReply = {
+  uid?: string
+  name?: string
+  author?: string
+  status?: Status
+  isPublished?: boolean
+  publishedAt?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type UpdateBookReq = {
+  uid?: string
+  author?: string
+  status?: Status
+}
+
+export type UpdateBookRely = {
+  uid?: string
+  name?: string
+  author?: string
+  status?: Status
+  isPublished?: boolean
+  publishedAt?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type DeleteBookReq = {
+  uid?: string
+}
+
+export class Book {
+  static Get(req: GetBookReq, initReq?: fm.InitReq): Promise<GetBookReply> {
+    return fm.fetchReq<GetBookReq, GetBookReply>(`/v1alpha1/books/${req["uid"]}?${fm.renderURLSearchParams(req, ["uid"])}`, {...initReq, method: "GET"})
+  }
+  static List(req: ListBookReq, initReq?: fm.InitReq): Promise<ListBookReply> {
+    return fm.fetchReq<ListBookReq, ListBookReply>(`/v1alpha1/books?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static Create(req: CreateBookReq, initReq?: fm.InitReq): Promise<CreateBookReply> {
+    return fm.fetchReq<CreateBookReq, CreateBookReply>(`/v1alpha1/books`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static Update(req: UpdateBookReq, initReq?: fm.InitReq): Promise<UpdateBookRely> {
+    return fm.fetchReq<UpdateBookReq, UpdateBookRely>(`/v1alpha1/books/${req["uid"]}`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static Delete(req: DeleteBookReq, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<DeleteBookReq, GoogleProtobufEmpty.Empty>(`/v1alpha1/books/${req["uid"]}`, {...initReq, method: "DELETE"})
+  }
+}

package/api/hive/v1alpha1/hive.pb.ts

@@ -0,0 +1,62 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "..\..\..\fetch.pb"
+import * as GoogleProtobufEmpty from "..\..\..\google\protobuf\empty.pb"
+import * as SkoalaApiGeneralV1alpha1Version from "..\..\general\v1alpha1\version.pb"
+import * as SkoalaApiIntegratedV1alpha1Instance from "..\..\integrated\v1alpha1\instance.pb"
+import * as SkoalaApiIntegratedV1alpha1Registry from "..\..\integrated\v1alpha1\registry.pb"
+import * as SkoalaApiIntegratedV1alpha1Service from "..\..\integrated\v1alpha1\service.pb"
+export class Hive {
+  static GetVersion(req: GoogleProtobufEmpty.Empty, initReq?: fm.InitReq): Promise<SkoalaApiGeneralV1alpha1Version.GetVersionRes> {
+    return fm.fetchReq<GoogleProtobufEmpty.Empty, SkoalaApiGeneralV1alpha1Version.GetVersionRes>(`/apis/hive.skoala.io/v1alpha1/version?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}
+export class Registry {
+  static List(req: SkoalaApiIntegratedV1alpha1Registry.ListRegistryReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Registry.ListRegistryRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Registry.ListRegistryReq, SkoalaApiIntegratedV1alpha1Registry.ListRegistryRes>(`/apis/hive.skoala.io/v1alpha1/registries?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static Get(req: SkoalaApiIntegratedV1alpha1Registry.GetRegistryReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Registry.GetRegistryRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Registry.GetRegistryReq, SkoalaApiIntegratedV1alpha1Registry.GetRegistryRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}?${fm.renderURLSearchParams(req, ["registryId"])}`, {...initReq, method: "GET"})
+  }
+  static Update(req: SkoalaApiIntegratedV1alpha1Registry.UpdateRegistryReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Registry.UpdateRegistryRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Registry.UpdateRegistryReq, SkoalaApiIntegratedV1alpha1Registry.UpdateRegistryRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static Create(req: SkoalaApiIntegratedV1alpha1Registry.CreateRegistryReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Registry.CreateRegistryRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Registry.CreateRegistryReq, SkoalaApiIntegratedV1alpha1Registry.CreateRegistryRes>(`/apis/hive.skoala.io/v1alpha1/registries`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static Delete(req: SkoalaApiIntegratedV1alpha1Registry.DeleteRegistryReq, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Registry.DeleteRegistryReq, GoogleProtobufEmpty.Empty>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}`, {...initReq, method: "DELETE"})
+  }
+  static Ping(req: SkoalaApiIntegratedV1alpha1Registry.PingRegistryReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Registry.PingRegistryRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Registry.PingRegistryReq, SkoalaApiIntegratedV1alpha1Registry.PingRegistryRes>(`/apis/hive.skoala.io/v1alpha1/registries/ping`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+}
+export class Service {
+  static ListAll(req: SkoalaApiIntegratedV1alpha1Service.ListServiceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Service.ListServiceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Service.ListServiceReq, SkoalaApiIntegratedV1alpha1Service.ListServiceRes>(`/apis/hive.skoala.io/v1alpha1/services?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static List(req: SkoalaApiIntegratedV1alpha1Service.ListServiceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Service.ListServiceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Service.ListServiceReq, SkoalaApiIntegratedV1alpha1Service.ListServiceRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}/services?${fm.renderURLSearchParams(req, ["registryId"])}`, {...initReq, method: "GET"})
+  }
+  static Get(req: SkoalaApiIntegratedV1alpha1Service.GetServiceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Service.GetServiceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Service.GetServiceReq, SkoalaApiIntegratedV1alpha1Service.GetServiceRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}/services/${req["serviceName"]}?${fm.renderURLSearchParams(req, ["registryId", "serviceName"])}`, {...initReq, method: "GET"})
+  }
+}
+export class Instance {
+  static ListAll(req: SkoalaApiIntegratedV1alpha1Instance.ListInstanceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Instance.ListInstanceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Instance.ListInstanceReq, SkoalaApiIntegratedV1alpha1Instance.ListInstanceRes>(`/apis/hive.skoala.io/v1alpha1/instances?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static ListRegistryAll(req: SkoalaApiIntegratedV1alpha1Instance.ListInstanceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Instance.ListInstanceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Instance.ListInstanceReq, SkoalaApiIntegratedV1alpha1Instance.ListInstanceRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}/instances?${fm.renderURLSearchParams(req, ["registryId"])}`, {...initReq, method: "GET"})
+  }
+  static List(req: SkoalaApiIntegratedV1alpha1Instance.ListInstanceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Instance.ListInstanceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Instance.ListInstanceReq, SkoalaApiIntegratedV1alpha1Instance.ListInstanceRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}/services/${req["serviceName"]}/instances?${fm.renderURLSearchParams(req, ["registryId", "serviceName"])}`, {...initReq, method: "GET"})
+  }
+  static Get(req: SkoalaApiIntegratedV1alpha1Instance.GetInstanceReq, initReq?: fm.InitReq): Promise<SkoalaApiIntegratedV1alpha1Instance.GetInstanceRes> {
+    return fm.fetchReq<SkoalaApiIntegratedV1alpha1Instance.GetInstanceReq, SkoalaApiIntegratedV1alpha1Instance.GetInstanceRes>(`/apis/hive.skoala.io/v1alpha1/registries/${req["registryId"]}/services/${req["serviceName"]}/instances/${req["instanceId"]}?${fm.renderURLSearchParams(req, ["registryId", "serviceName", "instanceId"])}`, {...initReq, method: "GET"})
+  }
+}

package/api/integrated/v1alpha1/instance.pb.ts

@@ -0,0 +1,43 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as SkoalaApiIntegratedV1alpha1Registry from ".\registry.pb"
+export type Instance = {
+  id?: string
+  serviceName?: string
+  frameworkType?: string
+  host?: string
+  port?: number
+  metadata?: {[key: string]: string}
+  registry?: SkoalaApiIntegratedV1alpha1Registry.Registry
+  detail?: {[key: string]: string}
+}
+
+export type ListInstanceReq = {
+  registryId?: string
+  namespaceId?: string
+  groupName?: string
+  serviceName?: string
+}
+
+export type GetInstanceReq = {
+  registryId?: string
+  namespaceId?: string
+  groupName?: string
+  serviceName?: string
+  instanceId?: string
+}
+
+export type ListInstanceRes = {
+  instances?: Instance[]
+  page?: number
+  size?: number
+  total?: number
+}
+
+export type GetInstanceRes = {
+  instance?: Instance
+}

package/api/integrated/v1alpha1/registry.pb.ts

@@ -0,0 +1,77 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+export type Registry = {
+  registryId?: string
+  name?: string
+  type?: string
+  addresses?: string[]
+  namespaces?: Namespace[]
+  serviceCount?: number
+}
+
+export type ListRegistryReq = {
+  page?: number
+  size?: number
+}
+
+export type ListRegistryRes = {
+  registries?: Registry[]
+  page?: number
+  size?: number
+  total?: number
+}
+
+export type GetRegistryReq = {
+  registryId?: string
+}
+
+export type GetRegistryRes = {
+  registry?: Registry
+}
+
+export type UpdateRegistryReq = {
+  registryId?: string
+  name?: string
+  type?: string
+  addresses?: string
+  namespaces?: string
+}
+
+export type UpdateRegistryRes = {
+  registry?: Registry
+}
+
+export type CreateRegistryReq = {
+  name?: string
+  type?: string
+  addresses?: string
+  namespaces?: string
+}
+
+export type CreateRegistryRes = {
+  registry?: Registry
+}
+
+export type DeleteRegistryReq = {
+  registryId?: string
+}
+
+export type PingRegistryReq = {
+  type?: string
+  addresses?: string
+  namespaces?: string
+}
+
+export type PingRegistryRes = {
+  serviceCount?: number
+  namespaces?: Namespace[]
+}
+
+export type Namespace = {
+  id?: string
+  name?: string
+  group?: string
+}

package/api/integrated/v1alpha1/service.pb.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as SkoalaApiIntegratedV1alpha1Registry from ".\registry.pb"
+export type Service = {
+  name?: string
+  namespace?: SkoalaApiIntegratedV1alpha1Registry.Namespace
+  instanceCount?: number
+  registry?: SkoalaApiIntegratedV1alpha1Registry.Registry
+  detail?: {[key: string]: string}
+}
+
+export type ListServiceReq = {
+  registryId?: string
+  page?: number
+  size?: number
+}
+
+export type ListServiceRes = {
+  services?: Service[]
+  page?: number
+  size?: number
+  total?: number
+}
+
+export type GetServiceReq = {
+  registryId?: string
+  namespaceId?: string
+  groupName?: string
+  serviceName?: string
+}
+
+export type GetServiceRes = {
+  service?: Service
+}

package/fetch.pb.ts

@@ -0,0 +1,232 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export interface InitReq extends RequestInit {
+  pathPrefix?: string
+}
+
+export function fetchReq<I, O>(path: string, init?: InitReq): Promise<O> {
+  const {pathPrefix, ...req} = init || {}
+
+  const url = pathPrefix ? `${pathPrefix}${path}` : path
+
+  return fetch(url, req).then(r => r.json().then((body: O) => {
+    if (!r.ok) { throw body; }
+    return body;
+  })) as Promise<O>
+}
+
+// NotifyStreamEntityArrival is a callback that will be called on streaming entity arrival
+export type NotifyStreamEntityArrival<T> = (resp: T) => void
+
+/**
+ * fetchStreamingRequest is able to handle grpc-gateway server side streaming call
+ * it takes NotifyStreamEntityArrival that lets users respond to entity arrival during the call
+ * all entities will be returned as an array after the call finishes.
+ **/
+export async function fetchStreamingRequest<S, R>(path: string, callback?: NotifyStreamEntityArrival<R>, init?: InitReq) {
+  const {pathPrefix, ...req} = init || {}
+  const url = pathPrefix ?`${pathPrefix}${path}` : path
+  const result = await fetch(url, req)
+  // needs to use the .ok to check the status of HTTP status code
+  // http other than 200 will not throw an error, instead the .ok will become false.
+  // see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#
+  if (!result.ok) {
+    const resp = await result.json()
+    const errMsg = resp.error && resp.error.message ? resp.error.message : ""
+    throw new Error(errMsg)
+  }
+
+  if (!result.body) {
+    throw new Error("response doesnt have a body")
+  }
+
+  await result.body
+    .pipeThrough(new TextDecoderStream())
+    .pipeThrough<R>(getNewLineDelimitedJSONDecodingStream<R>())
+    .pipeTo(getNotifyEntityArrivalSink((e: R) => {
+      if (callback) {
+        callback(e)
+      }
+    }))
+
+  // wait for the streaming to finish and return the success respond
+  return
+}
+
+/**
+ * JSONStringStreamController represents the transform controller that's able to transform the incoming
+ * new line delimited json content stream into entities and able to push the entity to the down stream
+ */
+interface JSONStringStreamController<T> extends TransformStreamDefaultController {
+  buf?: string
+  pos?: number
+  enqueue: (s: T) => void
+}
+
+/**
+ * getNewLineDelimitedJSONDecodingStream returns a TransformStream that's able to handle new line delimited json stream content into parsed entities
+ */
+function getNewLineDelimitedJSONDecodingStream<T>(): TransformStream<string, T> {
+  return new TransformStream({
+    start(controller: JSONStringStreamController<T>) {
+      controller.buf = ''
+      controller.pos = 0
+    },
+
+    transform(chunk: string, controller: JSONStringStreamController<T>) {
+      if (controller.buf === undefined) {
+        controller.buf = ''
+      }
+      if (controller.pos === undefined) {
+        controller.pos = 0
+      }
+      controller.buf += chunk
+      while (controller.pos < controller.buf.length) {
+        if (controller.buf[controller.pos] === '\n') {
+          const line = controller.buf.substring(0, controller.pos)
+          const response = JSON.parse(line)
+          controller.enqueue(response.result)
+          controller.buf = controller.buf.substring(controller.pos + 1)
+          controller.pos = 0
+        } else {
+          ++controller.pos
+        }
+      }
+    }
+  })
+
+}
+
+/**
+ * getNotifyEntityArrivalSink takes the NotifyStreamEntityArrival callback and return
+ * a sink that will call the callback on entity arrival
+ * @param notifyCallback
+ */
+function getNotifyEntityArrivalSink<T>(notifyCallback: NotifyStreamEntityArrival<T>) {
+  return new WritableStream<T>({
+    write(entity: T) {
+      notifyCallback(entity)
+    }
+  })
+}
+
+type Primitive = string | boolean | number;
+type RequestPayload = Record<string, unknown>;
+type FlattenedRequestPayload = Record<string, Primitive | Array<Primitive>>;
+
+/**
+ * Checks if given value is a plain object
+ * Logic copied and adapted from below source: 
+ * https://github.com/char0n/ramda-adjunct/blob/master/src/isPlainObj.js
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPlainObject(value: unknown): boolean {
+  const isObject =
+    Object.prototype.toString.call(value).slice(8, -1) === "Object";
+  const isObjLike = value !== null && isObject;
+
+  if (!isObjLike || !isObject) {
+    return false;
+  }
+
+  const proto = Object.getPrototypeOf(value);
+
+  const hasObjectConstructor =
+    typeof proto === "object" &&
+    proto.constructor === Object.prototype.constructor;
+
+  return hasObjectConstructor;
+}
+
+/**
+ * Checks if given value is of a primitive type
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPrimitive(value: unknown): boolean {
+  return ["string", "number", "boolean"].some(t => typeof value === t);
+}
+
+/**
+ * Checks if given primitive is zero-value
+ * @param  {Primitive} value
+ * @return {boolean}
+ */
+function isZeroValuePrimitive(value: Primitive): boolean {
+  return value === false || value === 0 || value === "";
+}
+
+/**
+ * Flattens a deeply nested request payload and returns an object
+ * with only primitive values and non-empty array of primitive values
+ * as per https://github.com/googleapis/googleapis/blob/master/google/api/http.proto
+ * @param  {RequestPayload} requestPayload
+ * @param  {String} path
+ * @return {FlattenedRequestPayload>}
+ */
+function flattenRequestPayload<T extends RequestPayload>(
+  requestPayload: T,
+  path: string = ""
+): FlattenedRequestPayload {
+  return Object.keys(requestPayload).reduce(
+    (acc: T, key: string): T => {
+      const value = requestPayload[key];
+      const newPath = path ? [path, key].join(".") : key;
+
+      const isNonEmptyPrimitiveArray =
+        Array.isArray(value) &&
+        value.every(v => isPrimitive(v)) &&
+        value.length > 0;
+
+      const isNonZeroValuePrimitive =
+        isPrimitive(value) && !isZeroValuePrimitive(value as Primitive);
+
+      let objectToMerge = {};
+
+      if (isPlainObject(value)) {
+        objectToMerge = flattenRequestPayload(value as RequestPayload, newPath);
+      } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
+        objectToMerge = { [newPath]: value };
+      }
+
+      return { ...acc, ...objectToMerge };
+    },
+    {} as T
+  ) as FlattenedRequestPayload;
+}
+
+/**
+ * Renders a deeply nested request payload into a string of URL search
+ * parameters by first flattening the request payload and then removing keys
+ * which are already present in the URL path.
+ * @param  {RequestPayload} requestPayload
+ * @param  {string[]} urlPathParams
+ * @return {string}
+ */
+export function renderURLSearchParams<T extends RequestPayload>(
+  requestPayload: T,
+  urlPathParams: string[] = []
+): string {
+  const flattenedRequestPayload = flattenRequestPayload(requestPayload);
+
+  const urlSearchParams = Object.keys(flattenedRequestPayload).reduce(
+    (acc: string[][], key: string): string[][] => {
+      // key should not be present in the url path as a parameter
+      const value = flattenedRequestPayload[key];
+      if (urlPathParams.find(f => f === key)) {
+        return acc;
+      }
+      return Array.isArray(value)
+        ? [...acc, ...value.map(m => [key, m.toString()])]
+        : (acc = [...acc, [key, value.toString()]]);
+    },
+    [] as string[][]
+  );
+
+  return new URLSearchParams(urlSearchParams).toString();
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@daocloud-proto/skoala",
+  "version": "0.2.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}