@ai0x0/utils 0.0.0

package/es/backend/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,CAAC,EAAc,MAAM,KAAK,CAAC;AAClD,OAAO,EACL,mBAAmB,EAEnB,uBAAuB,EAGxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAMtD,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAmBhE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;sFAaV,CAAC;AAGnB,eAAO,MAAM,cAAc;;;;;;;;;EAIvB,CAAC;AAGL,eAAO,MAAM,iBAAiB;;;0BAWpB,wBACJ,MAAM,EACN,OAAO,MAAM,EAAE,mBAAmB,CAAC,EACnC,IAAI,CACL,KACE,uBAAuB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC/B,CAAC"}

package/es/backend/schemas/index.js

@@ -0,0 +1,87 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { z } from "zod";
+import { pgTable, timestamp, uuid } from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+//============================基本字段============================//
+var timestamptz = function timestamptz(name) {
+  return timestamp(name, {
+    withTimezone: true
+  });
+};
+var createdAt = function createdAt() {
+  return timestamptz("created_at").notNull().defaultNow();
+};
+var updatedAt = function updatedAt() {
+  return timestamptz("updated_at").notNull().defaultNow();
+};
+var accessedAt = function accessedAt() {
+  return timestamptz("accessed_at").notNull().defaultNow();
+};
+var basicFields = {
+  id: uuid("id").defaultRandom().primaryKey(),
+  creatorId: uuid("creator_id"),
+  editorId: uuid("editor_id"),
+  accessedAt: accessedAt(),
+  createdAt: createdAt(),
+  updatedAt: updatedAt()
+};
+
+//============================列表查询字段============================//
+export var queryListSchema = function queryListSchema(schema) {
+  return z.object({
+    current: z.string().optional().default("1"),
+    // 默认页码为 1
+    pageSize: z.string().optional().default("10"),
+    // 默认每页条数为 10
+    createdAtFrom: z.string().optional(),
+    // 筛选开始日期
+    createdAtTo: z.string().optional(),
+    // 筛选结束日期
+    orderBy: z.string().optional(),
+    creatorId: z.string().optional(),
+    orderDir: z.enum(["asc", "desc"]).optional()
+  }).merge(schema);
+};
+
+//============================列表返回字段============================//
+export var listBodySchema = function listBodySchema(schema) {
+  return z.object({
+    total: z.number(),
+    data: z.array(schema)
+  });
+};
+
+//============================创建一个pg表============================//
+export var createTableSchema = function createTableSchema(_ref) {
+  var name = _ref.name,
+    columns = _ref.columns,
+    extraConfig = _ref.extraConfig;
+  // 创建表
+  var table = pgTable(name, _objectSpread(_objectSpread({}, basicFields), columns), extraConfig);
+  // 创建基础的schema
+  var selectSchema = createSelectSchema(table);
+  return {
+    table: table,
+    selectSchema: selectSchema,
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    insertSchema: createInsertSchema(table, {}),
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    updateSchema: createUpdateSchema(table, {
+      id: z.string()
+    }),
+    querySchema: selectSchema.pick({
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      id: true
+    }),
+    queryListSchema: queryListSchema(selectSchema.partial()),
+    queryListSelectSchema: selectSchema
+  };
+};

package/es/backend/types.d.ts

@@ -0,0 +1,13 @@
+import { PgColumn, PgTable } from "drizzle-orm/pg-core";
+import { SQL } from "drizzle-orm";
+export interface BaseTable extends PgTable {
+    createdAt: PgColumn;
+    id: PgColumn;
+}
+export type GetListRelations = {
+    groupBy?: boolean;
+    select?: Record<string, unknown>;
+    sql?: SQL;
+    table?: BaseTable;
+}[];
+//# sourceMappingURL=types.d.ts.map

package/es/backend/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAGlC,MAAM,WAAW,SAAU,SAAQ,OAAO;IACxC,SAAS,EAAE,QAAQ,CAAC;IACpB,EAAE,EAAE,QAAQ,CAAC;CACd;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB,EAAE,CAAC"}

package/es/backend/types.js

@@ -0,0 +1 @@
+export {};

package/es/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":""}

package/lib/backend/actions/delete-action-fn.d.ts

@@ -0,0 +1,7 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { BaseTable } from "../types";
+export declare function deleteActionFn<TTable extends BaseTable>({ table, db, }: {
+    db: NodePgDatabase<any>;
+    table: TTable;
+}): any;
+//# sourceMappingURL=delete-action-fn.d.ts.map

package/lib/backend/actions/delete-action-fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-action-fn.d.ts","sourceRoot":"","sources":["delete-action-fn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,SAAS,EAAE,iBAAwB;AAE5C,wBAAgB,cAAc,CAAC,MAAM,SAAS,SAAS,EAAE,EACvD,KAAK,EACL,EAAE,GACH,EAAE;IACD,EAAE,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf,OASA"}

package/lib/backend/actions/delete-action-fn.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/actions/delete-action-fn.ts
+var delete_action_fn_exports = {};
+__export(delete_action_fn_exports, {
+  deleteActionFn: () => deleteActionFn
+});
+module.exports = __toCommonJS(delete_action_fn_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_zod = require("zod");
+var import_drizzle_orm = require("drizzle-orm");
+function deleteActionFn({
+  table,
+  db
+}) {
+  return (0, import_next_rest_framework.rpcOperation)().input({
+    body: import_zod.z.string(),
+    contentType: "application/json"
+  }).handler(async (id) => {
+    return db.delete(table).where((0, import_drizzle_orm.eq)(table.id, id)).returning();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteActionFn
+});

package/lib/backend/actions/get-List-query.d.ts

@@ -0,0 +1,30 @@
+import { BaseTable, GetListRelations } from "../types";
+import { SelectedFields } from "drizzle-orm/pg-core/query-builders/select.types";
+import { SQL } from "drizzle-orm";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+export declare function getListQuery<TTable extends BaseTable, TSelection extends SelectedFields>({ db, fields, jsonArrayFields, params, relations, table, }: {
+    db: NodePgDatabase<any>;
+    fields: TSelection;
+    jsonArrayFields?: string[];
+    params: {
+        [field: string]: any;
+        orderBy?: keyof BaseTable;
+        orderDir?: "asc" | "desc";
+        page?: number;
+        pageSize?: number;
+    };
+    relations?: GetListRelations;
+    table: TTable;
+}): {
+    countQuery: Omit<import("drizzle-orm/pg-core").PgSelectBase<any, {
+        count: SQL<unknown>;
+    }, "partial", {} | Record<any, "not-null">, false, "where", ({
+        count: unknown;
+    } | {
+        count: unknown;
+    })[], {
+        count: import("drizzle-orm").DrizzleTypeError<"You cannot reference this field without assigning it an alias first - use `.as(<alias>)`">;
+    }>, "where">;
+    query: any;
+};
+//# sourceMappingURL=get-List-query.d.ts.map

package/lib/backend/actions/get-List-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-List-query.d.ts","sourceRoot":"","sources":["get-List-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAwB;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AACjF,OAAO,EAYL,GAAG,EACJ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,wBAAgB,YAAY,CAC1B,MAAM,SAAS,SAAS,EACxB,UAAU,SAAS,cAAc,EACjC,EACA,EAAE,EACF,MAAM,EACN,eAAe,EACf,MAAM,EACN,SAAS,EACT,KAAK,GACN,EAAE;IACD,EAAE,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IACxB,MAAM,EAAE,UAAU,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE;QAEN,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC;QAErB,OAAO,CAAC,EAAE,MAAM,SAAS,CAAC;QAE1B,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;QAEd,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;;;;;;;;;;;EA6MA"}

package/lib/backend/actions/get-List-query.js

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/actions/get-List-query.ts
+var get_List_query_exports = {};
+__export(get_List_query_exports, {
+  getListQuery: () => getListQuery
+});
+module.exports = __toCommonJS(get_List_query_exports);
+var import_drizzle_orm = require("drizzle-orm");
+function getListQuery({
+  db,
+  fields,
+  jsonArrayFields,
+  params,
+  relations,
+  table
+}) {
+  const {
+    page = 1,
+    pageSize = 10,
+    orderBy = "createdAt",
+    orderDir = "desc",
+    ...filters
+  } = params;
+  function buildBaseQuery(table2, fields2, relations2) {
+    let queryFields = { ...fields2 };
+    if (relations2 == null ? void 0 : relations2.length) {
+      for (const { select } of relations2) {
+        queryFields = { ...queryFields, ...select };
+      }
+    }
+    const query2 = db.select(queryFields).from(table2);
+    if (relations2 == null ? void 0 : relations2.length) {
+      query2.groupBy(
+        table2.id,
+        ...relations2.filter(({ groupBy }) => groupBy).filter(({ table: table3 }) => table3).map(({ table: table3 }) => table3.id)
+      );
+    }
+    return query2;
+  }
+  function findTargetColumn(key, table2, relations2) {
+    var _a;
+    return (_a = [table2].concat(
+      (relations2 == null ? void 0 : relations2.filter(({ table: table3 }) => table3).map(({ table: table3 }) => table3)) || []
+    ).find((t) => t[key])) == null ? void 0 : _a[key];
+  }
+  function addCondition(conditions2, key, value, targetColumn) {
+    const isIdField = /id/i.test(key);
+    const isJsonArray = jsonArrayFields == null ? void 0 : jsonArrayFields.includes(key);
+    if (typeof value === "string") {
+      if (value.includes(",")) {
+        const values = value.split(",").map((v) => v.trim()).filter(Boolean);
+        if (values.length > 0) {
+          if (isJsonArray) {
+            conditions2.push(
+              import_drizzle_orm.sql`
+                EXISTS (
+                  SELECT 1 FROM jsonb_array_elements_text(${targetColumn}) tag
+                  WHERE tag LIKE ${`%${values[0]}%`}
+                )
+              `
+            );
+          } else if (isIdField) {
+            conditions2.push((0, import_drizzle_orm.inArray)(targetColumn, values));
+          } else {
+            conditions2.push(
+              (0, import_drizzle_orm.or)(
+                ...values.map((v) => (0, import_drizzle_orm.ilike)(targetColumn, `%${v}%`))
+              )
+            );
+          }
+        }
+      } else {
+        if (isJsonArray) {
+          conditions2.push(
+            import_drizzle_orm.sql`
+              EXISTS (
+                SELECT 1 FROM jsonb_array_elements_text(${targetColumn}) tag
+                WHERE tag LIKE ${`%${value}%`}
+              )
+            `
+          );
+        } else if (isIdField) {
+          conditions2.push((0, import_drizzle_orm.eq)(targetColumn, value));
+        } else {
+          conditions2.push((0, import_drizzle_orm.ilike)(targetColumn, `%${value}%`));
+        }
+      }
+    } else {
+      conditions2.push((0, import_drizzle_orm.eq)(targetColumn, value));
+    }
+  }
+  function buildConditions(filters2, table2, relations2) {
+    const conditions2 = [];
+    for (const [key, value] of Object.entries(filters2)) {
+      if (!value)
+        continue;
+      if (key.endsWith("AtFrom") || key.endsWith("AtTo")) {
+        const baseFieldName = key.replace(/(AtFrom|AtTo)$/, "");
+        const targetColumn2 = findTargetColumn(
+          `${baseFieldName}At`,
+          table2,
+          relations2
+        );
+        if (!targetColumn2)
+          continue;
+        if (key.endsWith("AtFrom")) {
+          conditions2.push((0, import_drizzle_orm.gte)(targetColumn2, new Date(value)));
+        } else if (key.endsWith("AtTo")) {
+          conditions2.push((0, import_drizzle_orm.lte)(targetColumn2, new Date(value)));
+        }
+        continue;
+      }
+      const targetColumn = findTargetColumn(
+        key,
+        table2,
+        relations2
+      );
+      if (!targetColumn)
+        continue;
+      addCondition(conditions2, key, value, targetColumn);
+    }
+    return conditions2;
+  }
+  function buildOrderBy(table2, orderBy2, orderDir2) {
+    const orderColumn = table2[orderBy2];
+    return orderDir2 === "asc" ? (0, import_drizzle_orm.asc)(orderColumn) : (0, import_drizzle_orm.desc)(orderColumn);
+  }
+  const baseQuery = buildBaseQuery(table, fields, relations);
+  const conditions = buildConditions(filters, table, relations);
+  const query = baseQuery.where(conditions.length > 0 ? (0, import_drizzle_orm.and)(...conditions) : void 0).orderBy(buildOrderBy(table, orderBy, orderDir)).limit(pageSize).offset((page - 1) * pageSize);
+  const countQuery = db.select({ count: import_drizzle_orm.sql`COUNT(DISTINCT ${table.id})` }).from(table).where(conditions.length > 0 ? (0, import_drizzle_orm.and)(...conditions) : void 0);
+  if (relations == null ? void 0 : relations.length) {
+    for (const { table: relationTable, sql: joinSql } of relations) {
+      if (relationTable) {
+        query.leftJoin(relationTable, joinSql);
+        countQuery.leftJoin(relationTable, joinSql);
+      }
+    }
+  }
+  return { countQuery, query };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getListQuery
+});

package/lib/backend/actions/get-action-fn.d.ts

@@ -0,0 +1,12 @@
+import { ZodSchema } from "zod";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { BaseTable, GetListRelations } from "../types";
+export declare function getActionFn<T extends ZodSchema, Q extends ZodSchema, TTable extends BaseTable>({ bodySchema, db, jsonArrayFields, querySchema, relations, table, }: {
+    bodySchema: T;
+    db: NodePgDatabase<any>;
+    jsonArrayFields?: string[];
+    querySchema: Q;
+    relations?: GetListRelations;
+    table: TTable;
+}): any;
+//# sourceMappingURL=get-action-fn.d.ts.map

package/lib/backend/actions/get-action-fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-action-fn.d.ts","sourceRoot":"","sources":["get-action-fn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAGhC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAwB;AAE9D,wBAAgB,WAAW,CACzB,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,SAAS,EACnB,MAAM,SAAS,SAAS,EACxB,EACA,UAAU,EACV,EAAE,EACF,eAAe,EACf,WAAW,EACX,SAAS,EACT,KAAK,GACN,EAAE;IACD,UAAU,EAAE,CAAC,CAAC;IACd,EAAE,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,CAAC,CAAC;IACf,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf,OA8CA"}

package/lib/backend/actions/get-action-fn.js

@@ -0,0 +1,75 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/actions/get-action-fn.ts
+var get_action_fn_exports = {};
+__export(get_action_fn_exports, {
+  getActionFn: () => getActionFn
+});
+module.exports = __toCommonJS(get_action_fn_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_get_List_query = require("./get-List-query");
+var import_get_list_data = require("./get-list-data");
+function getActionFn({
+  bodySchema,
+  db,
+  jsonArrayFields,
+  querySchema,
+  relations,
+  table
+}) {
+  return (0, import_next_rest_framework.rpcOperation)().input({
+    body: querySchema,
+    contentType: "application/json"
+  }).outputs([
+    {
+      body: bodySchema,
+      contentType: "application/json"
+    }
+  ]).handler(async (params) => {
+    const fields = {};
+    for (const key of Object.keys(bodySchema.shape)) {
+      const field = table[key];
+      if (field) {
+        fields[key] = field;
+      }
+    }
+    const { query, countQuery } = (0, import_get_List_query.getListQuery)({
+      db,
+      fields,
+      jsonArrayFields,
+      params,
+      relations,
+      table
+    });
+    const {
+      data: [result]
+    } = await (0, import_get_list_data.getListData)({
+      bodySchema,
+      countQuery,
+      current: 1,
+      pageSize: 1,
+      query
+    })();
+    return result || {};
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getActionFn
+});

package/lib/backend/actions/get-list-action-fn.d.ts

@@ -0,0 +1,12 @@
+import { ZodSchema } from "zod";
+import { BaseTable, GetListRelations } from "../types";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+export declare function getListActionFn<T extends ZodSchema, Q extends ZodSchema, TTable extends BaseTable>({ bodySchema, db, jsonArrayFields, querySchema, relations, table, }: {
+    bodySchema: T;
+    db: NodePgDatabase<any>;
+    jsonArrayFields?: string[];
+    querySchema: Q;
+    relations?: GetListRelations;
+    table: TTable;
+}): any;
+//# sourceMappingURL=get-list-action-fn.d.ts.map

package/lib/backend/actions/get-list-action-fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-list-action-fn.d.ts","sourceRoot":"","sources":["get-list-action-fn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAwB;AAM9D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,wBAAgB,eAAe,CAC7B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,SAAS,EACnB,MAAM,SAAS,SAAS,EACxB,EACA,UAAU,EACV,EAAE,EACF,eAAe,EACf,WAAW,EACX,SAAS,EACT,KAAK,GACN,EAAE;IACD,UAAU,EAAE,CAAC,CAAC;IACd,EAAE,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,CAAC,CAAC;IACf,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf,OA2CA"}

package/lib/backend/actions/get-list-action-fn.js

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/actions/get-list-action-fn.ts
+var get_list_action_fn_exports = {};
+__export(get_list_action_fn_exports, {
+  getListActionFn: () => getListActionFn
+});
+module.exports = __toCommonJS(get_list_action_fn_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_schemas = require("../schemas");
+var import_get_List_query = require("./get-List-query");
+var import_get_list_data = require("./get-list-data");
+function getListActionFn({
+  bodySchema,
+  db,
+  jsonArrayFields,
+  querySchema,
+  relations,
+  table
+}) {
+  return (0, import_next_rest_framework.rpcOperation)().input({
+    body: querySchema,
+    contentType: "application/json"
+  }).outputs([
+    {
+      body: (0, import_schemas.listBodySchema)(bodySchema),
+      contentType: "application/json"
+    }
+  ]).handler(async (params) => {
+    const { current, pageSize, ...other } = params;
+    const fields = {};
+    for (const key of Object.keys(bodySchema.shape)) {
+      const field = table[key];
+      if (field) {
+        fields[key] = field;
+      }
+    }
+    const { query, countQuery } = (0, import_get_List_query.getListQuery)({
+      db,
+      fields,
+      jsonArrayFields,
+      params: other,
+      relations,
+      table
+    });
+    return (0, import_get_list_data.getListData)({
+      bodySchema,
+      countQuery,
+      current,
+      pageSize,
+      query
+    })();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getListActionFn
+});

package/lib/backend/actions/get-list-data.d.ts

@@ -0,0 +1,8 @@
+import { ZodSchema } from "zod";
+import { getListQuery } from "./get-List-query";
+export declare function getListData<B extends ZodSchema>({ query, countQuery, pageSize, current, bodySchema, }: {
+    bodySchema: B;
+    current?: number;
+    pageSize?: number;
+} & ReturnType<typeof getListQuery>): any;
+//# sourceMappingURL=get-list-data.d.ts.map

package/lib/backend/actions/get-list-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-list-data.d.ts","sourceRoot":"","sources":["get-list-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAChC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIhD,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,EAC/C,KAAK,EACL,UAAU,EACV,QAAa,EACb,OAAW,EACX,UAAU,GACX,EAAE;IACD,UAAU,EAAE,CAAC,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,OAoBlC"}

package/lib/backend/actions/get-list-data.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/actions/get-list-data.ts
+var get_list_data_exports = {};
+__export(get_list_data_exports, {
+  getListData: () => getListData
+});
+module.exports = __toCommonJS(get_list_data_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_schemas = require("../schemas");
+function getListData({
+  query,
+  countQuery,
+  pageSize = 10,
+  current = 1,
+  bodySchema
+}) {
+  return (0, import_next_rest_framework.rpcOperation)().outputs([
+    {
+      body: (0, import_schemas.listBodySchema)(bodySchema),
+      contentType: "application/json"
+    }
+  ]).handler(async () => {
+    const data = await query.limit(+pageSize).offset((+current - 1) * +pageSize).execute();
+    const [{ count }] = await countQuery.execute();
+    return { data, total: Number(count) };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getListData
+});

package/lib/backend/actions/index.d.ts

@@ -0,0 +1,6 @@
+export { deleteActionFn } from "./delete-action-fn";
+export { getActionFn } from "./get-action-fn";
+export { getListActionFn } from "./get-list-action-fn";
+export { postActionFn } from "./post-action-fn";
+export { putActionFn } from "./put-action-fn";
+//# sourceMappingURL=index.d.ts.map

package/lib/backend/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}