@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/server/db/seed.ts

@@ -0,0 +1,176 @@
+import { faker } from "@faker-js/faker/locale/nl_BE";
+import { reset, seed } from "drizzle-seed";
+import { COUNTRY_CODES, DEFAULT_ADDRESS_TYPE } from "@/app/admin/addresses/_lib/constants";
+import { projectStatusConfig } from "@/app/admin/projects/_config/status";
+import { generateDefaultUUID } from "./helpers";
+import { db } from "./init";
+import * as schema from "./schema";
+
+const seedSchema = {
+  addresses: schema.addresses,
+  contacts: schema.contacts,
+  clients: schema.clients,
+  clientsContacts: schema.clientsContacts,
+  clientsAddresses: schema.clientsAddresses,
+  suppliers: schema.suppliers,
+  suppliersContacts: schema.suppliersContacts,
+  suppliersAddresses: schema.suppliersAddresses,
+  projects: schema.projects,
+  tasks: schema.tasks,
+  products: schema.products,
+  categories: schema.categories,
+  emails: schema.emails,
+  // productImages: schema.productImages,
+  // assets: schema.assets,
+};
+
+console.info("🌱  The seed command has been started. \n");
+
+console.info("🗑️  Resetting the database...");
+await reset(db, seedSchema);
+
+console.info("--------------------");
+
+console.info("🌱  Seeding the database...");
+const ids = Array.from({ length: 100000 }, () => generateDefaultUUID());
+
+await seed(db, seedSchema).refine((f) => ({
+  addresses: {
+    count: 100,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      street: f.streetAddress(),
+      postalCode: f.postcode(),
+      city: f.city(),
+      countryCode: f.valuesFromArray({ values: COUNTRY_CODES }),
+      type: f.default({ defaultValue: DEFAULT_ADDRESS_TYPE }),
+      //   type: f.valuesFromArray({ values: ADDRESS_TYPES.map((type) => type.id) }),
+      name: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+  },
+  contacts: {
+    count: 150,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      firstName: f.firstName(),
+      lastName: f.lastName(),
+      email: f.email(),
+      phone: f.phoneNumber({ template: "+32 484 ## ## ##" }),
+      position: f.jobTitle(),
+    },
+  },
+  // clients: {
+  //   count: 50,
+  //   columns: {
+  // id: f.valuesFromArray({ values: ids, isUnique: true }),
+  //     name: f.companyName({ isUnique: true }),
+  //     tradeName: f.default({ defaultValue: null }),
+  //     vat: f.valuesFromArray({
+  //       values: Array.from(
+  //         { length: 50 },
+  //         () => `BE${faker.number.bigInt({ min: 10000000000, max: 99999999999 })}`,
+  //       ),
+  //     }),
+  //     email: f.email(),
+  //     phone: f.phoneNumber({ template: "011 ## ## ##" }),
+  //     website: f.default({ defaultValue: null }),
+  //     notes: f.default({ defaultValue: null }),
+  //     isDeleted: f.boolean(),
+  //   },
+  //   with: {
+  //     customersAddresses: 1,
+  //     customersContacts: 1,
+  //   },
+  // },
+  suppliers: {
+    count: 50,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      name: f.companyName({ isUnique: true }),
+      tradeName: f.default({ defaultValue: null }),
+      vat: f.valuesFromArray({
+        values: Array.from(
+          { length: 50 },
+          () => `BE${faker.number.bigInt({ min: 10000000000, max: 99999999999 })}`,
+        ),
+      }),
+      email: f.email(),
+      phone: f.phoneNumber({ template: "011 ## ## ##" }),
+      website: f.default({ defaultValue: null }),
+      notes: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+    with: {
+      suppliersAddresses: 1,
+      suppliersContacts: 1,
+    },
+  },
+  projects: {
+    count: 30,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      name: f.companyName({ isUnique: true }),
+      budget: f.int({ minValue: 0, maxValue: 100000 }),
+      startDate: f.date({ maxDate: new Date() }),
+      deadline: f.date({ minDate: new Date() }),
+      notes: f.default({ defaultValue: null }),
+      endDate: f.default({ defaultValue: null }),
+      status: f.valuesFromArray({ values: projectStatusConfig.flatMap(({ value }) => value) }),
+      isDeleted: f.weightedRandom([
+        { weight: 0.8, value: f.default({ defaultValue: false }) },
+        { weight: 0.2, value: f.default({ defaultValue: true }) },
+      ]),
+    },
+    with: {
+      tasks: [
+        { weight: 0.2, count: 100 },
+        { weight: 0.2, count: 50 },
+        { weight: 0.2, count: 10 },
+        { weight: 0.4, count: 30 },
+      ],
+    },
+  },
+  tasks: {
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      articleNumber: f.valuesFromArray({
+        values: Array.from({ length: 1000 }, () => faker.hacker.phrase()),
+      }),
+      status: f.valuesFromArray({ values: schema.taskStatusEnum.enumValues }),
+      description: f.default({ defaultValue: f.loremIpsum({ sentencesCount: 1 }) }),
+      // description: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+  },
+  products: {
+    count: 900,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      articleNumber: f.string({ isUnique: true }),
+      name: f.companyName({ isUnique: true }),
+      buyPrice: f.int({ minValue: 0, maxValue: 100000 }),
+      brand: f.valuesFromArray({
+        values: Array.from({ length: 20 }, () => faker.company.name()),
+      }),
+      notes: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+  },
+  categories: {
+    count: 10,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      name: f.companyName({ isUnique: true }),
+    },
+    with: {
+      products: 90,
+    },
+  },
+}));
+
+console.info("✅  The seed command has been completed.");
+
+console.info("--------------------");
+
+process.exit(0);

package/dist/templates/spark/src/server/db/types.ts

@@ -0,0 +1,3 @@
+import type * as schema from "./schema";
+
+export type DatabaseSchema = typeof schema;

package/dist/templates/spark/src/server/drive-local/schema.ts

@@ -0,0 +1,83 @@
+import { imageVariants, nodeSubtypes } from "@tulip-systems/drive-local";
+import { imageDispositions } from "@tulip-systems/storage";
+import { relations } from "drizzle-orm";
+import { type AnyPgColumn, boolean, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+import { baseColumns } from "../db/helpers";
+import { storageAssets } from "../storage/schema";
+
+export const nodeTypeEnum = pgEnum("node_types", ["file", "folder"]);
+
+export const nodes = pgTable("nodes", (t) => ({
+  ...baseColumns,
+  name: t.text().notNull(),
+  namespace: t.text().notNull().default("global"),
+  type: nodeTypeEnum(),
+  subtype: t.text({ enum: nodeSubtypes }).notNull().default("other"),
+  size: t.integer(),
+  contentType: t.varchar({ length: 255 }),
+  readonly: boolean().default(false),
+  hidden: boolean().default(false),
+  archivedAt: t.timestamp(),
+  parentId: t.uuid().references((): AnyPgColumn => nodes.id, { onDelete: "cascade" }),
+  assetId: t.uuid().references(() => storageAssets.id, { onDelete: "cascade" }),
+}));
+
+export const nodesRelations = relations(nodes, ({ one, many }) => ({
+  parent: one(nodes, {
+    fields: [nodes.parentId],
+    references: [nodes.id],
+    relationName: "parent",
+  }),
+  children: many(nodes, {
+    relationName: "parent",
+  }),
+  urls: many(nodePresignedUrls),
+  variants: many(nodeVariants),
+}));
+
+export const nodeVariants = pgTable("node_variants", (t) => ({
+  ...baseColumns,
+  nodeId: t
+    .uuid()
+    .notNull()
+    .references(() => nodes.id, { onDelete: "cascade" }),
+  assetId: t
+    .uuid()
+    .notNull()
+    .references(() => storageAssets.id, { onDelete: "cascade" }),
+  variant: t.text({ enum: imageVariants }).notNull(),
+  width: t.integer().notNull(),
+}));
+
+export const nodeVariantsRelations = relations(nodeVariants, ({ one }) => ({
+  node: one(nodes, {
+    fields: [nodeVariants.nodeId],
+    references: [nodes.id],
+    relationName: "node",
+  }),
+}));
+
+export const nodePresignedUrls = pgTable(
+  "node_presigned_urls",
+  (t) => ({
+    ...baseColumns,
+    url: t.text().notNull().unique(),
+    variant: t.text({ enum: imageVariants }).notNull(),
+    disposition: t.text({ enum: imageDispositions }).notNull(),
+    expiresAt: t.timestamp().notNull(),
+    nodeId: t
+      .uuid()
+      .notNull()
+      .references(() => nodes.id, { onDelete: "cascade" }),
+    variantId: t.uuid().references(() => nodeVariants.id, { onDelete: "set null" }),
+  }),
+  (t) => [unique("node_presigned_url_unique").on(t.nodeId, t.variant, t.disposition)],
+);
+
+export const nodePresignedUrlsRelations = relations(nodePresignedUrls, ({ one }) => ({
+  node: one(nodes, {
+    fields: [nodePresignedUrls.nodeId],
+    references: [nodes.id],
+    relationName: "node",
+  }),
+}));

package/dist/templates/spark/src/server/emails/init.ts

@@ -0,0 +1,4 @@
+import { Resend } from "resend";
+import { env } from "@/env";
+
+export const email = new Resend(env.RESEND_API_KEY);

package/dist/templates/spark/src/server/router/caller.ts

@@ -0,0 +1,10 @@
+import "server-only";
+
+import { createRouterClient } from "@orpc/server";
+import { headers } from "next/headers";
+import { createContext } from "./init";
+import { appRouter } from "./router";
+
+export const caller = createRouterClient(appRouter, {
+  context: async () => createContext({ headers: await headers() }),
+});

package/dist/templates/spark/src/server/router/client.ts

@@ -0,0 +1,28 @@
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import type { RouterClient } from "@orpc/server";
+import { createTanstackQueryUtils, type RouterUtils } from "@orpc/tanstack-query";
+import type { AppRouter } from "./router";
+
+type ORPCClient = RouterClient<AppRouter>;
+type ORPCTanstackQueryUtils = RouterUtils<ORPCClient>;
+
+declare global {
+  var $client: ORPCClient | undefined;
+}
+
+const link = new RPCLink({
+  url: () => {
+    if (typeof window === "undefined") {
+      throw new Error("RPCLink is not allowed on the server side.");
+    }
+
+    return `${window.location.origin}/api/rpc`;
+  },
+});
+
+const client: ORPCClient = createORPCClient(link);
+
+const activeClient: ORPCClient = globalThis.$client ?? client;
+
+export const orpc: ORPCTanstackQueryUtils = createTanstackQueryUtils(activeClient);

package/dist/templates/spark/src/server/router/init.ts

@@ -0,0 +1,17 @@
+import "server-cli-only";
+
+import { os } from "@orpc/server";
+import { auth } from "../auth/init";
+import { db } from "../db/init";
+
+export type RPCContext = {
+  db: typeof db;
+  auth: typeof auth;
+  headers: Headers;
+};
+
+export const rpc = os.$context<RPCContext>();
+
+export function createContext<TExtendedContext>(context: TExtendedContext & { headers: Headers }) {
+  return { db, auth, ...context } as RPCContext & TExtendedContext;
+}

package/dist/templates/spark/src/server/router/middleware.ts

@@ -0,0 +1,45 @@
+import { ORPCError, os } from "@orpc/server";
+import type { AuthServerSession, AuthServerUser } from "@tulip-systems/auth";
+import type { Permission } from "@tulip-systems/auth/permissions";
+import type { AuthServerOptions } from "../auth/init";
+import type { AccessControl } from "../auth/permissions";
+import { type RPCContext, rpc } from "./init";
+
+export const sessionMiddleware = rpc.middleware(async ({ next, context }) => {
+  const data = await context.auth.api.getSession({ headers: context.headers });
+
+  if (!data?.session || !data?.user) {
+    throw new ORPCError("UNAUTHORIZED", {
+      message: "Jou hebt geen toegang om deze actie uit te voeren",
+    });
+  }
+
+  const { session, user } = data;
+
+  return next({ context: { session, user } });
+});
+
+export type ProtectedContext = RPCContext & {
+  session: AuthServerSession<AuthServerOptions>;
+  user: AuthServerUser<AuthServerOptions>;
+};
+
+export function permissionMiddleware(permissions: Permission<AccessControl>) {
+  return os.$context<ProtectedContext>().middleware(async ({ next, context }) => {
+    const { success, error } = await context.auth.api.userHasPermission({
+      headers: context.headers as Headers,
+      body: {
+        userId: context.user.id,
+        permissions,
+      },
+    });
+
+    if (error || !success) {
+      throw new ORPCError("UNAUTHORIZED", {
+        message: "Jou hebt geen toegang om deze actie uit te voeren",
+      });
+    }
+
+    return next({ context });
+  });
+}

package/dist/templates/spark/src/server/router/procedures.ts

@@ -0,0 +1,5 @@
+import { rpc } from "./init";
+import { sessionMiddleware } from "./middleware";
+
+export const publicProcedure = rpc;
+export const protectedProcedure = rpc.use(sessionMiddleware);

package/dist/templates/spark/src/server/router/register.ts

@@ -0,0 +1,5 @@
+import "server-only";
+
+import { caller } from "./caller";
+
+globalThis.$client ??= caller;

package/dist/templates/spark/src/server/router/router.ts

@@ -0,0 +1,73 @@
+import type { InferRouterInputs, InferRouterOutputs } from "@orpc/server";
+
+import { addressesRouter } from "@/app/admin/addresses/_lib/router";
+import { assignmentsRouter } from "@/app/admin/assignments/_lib/router";
+import { clientsRouter } from "@/app/admin/clients/_lib/router";
+import { companiesRouter } from "@/app/admin/companies/_lib/router";
+import { contactsRouter } from "@/app/admin/contacts/_lib/router";
+import { customersRouter } from "@/app/admin/customers/_lib/router";
+import { driveRouter } from "@/app/admin/drive/_lib/router";
+import { emailsRouter } from "@/app/admin/emails/_lib/router";
+import { employeesRouter } from "@/app/admin/employees/_lib/router";
+import { executionsRouter } from "@/app/admin/executions/_lib/router";
+import { productImagesRouter, productsRouter } from "@/app/admin/products/_lib/router";
+import { projectsRouter } from "@/app/admin/projects/_lib/router";
+import { purchaseOrderItemsRouter } from "@/app/admin/purchase-order-items/_lib/router";
+import { purchaseOrdersRouter } from "@/app/admin/purchase-orders/_lib/router";
+import { quotationItemsRouter } from "@/app/admin/quotation-items/_lib/router";
+import { quotationsRouter } from "@/app/admin/quotations/_lib/router";
+import { registrationsRouter } from "@/app/admin/registrations/_lib/router";
+import { runTasksRouter } from "@/app/admin/run-tasks/_lib/router";
+import { runsRouter } from "@/app/admin/runs/_lib/router";
+import { salesInvoiceItemsRouter } from "@/app/admin/sales-invoice-items/_lib/router";
+import { salesInvoicesRouter } from "@/app/admin/sales-invoices/_lib/router";
+import { salesOrderExecutionsRouter } from "@/app/admin/sales-order-executions/_lib/router";
+import { salesOrderItemsRouter } from "@/app/admin/sales-order-items/_lib/router";
+import { salesOrdersRouter } from "@/app/admin/sales-orders/_lib/router";
+import { subprojectsRouter } from "@/app/admin/subprojects/_lib/router";
+import { suppliersRouter } from "@/app/admin/suppliers/_lib/router";
+import { tasksRouter } from "@/app/admin/tasks/_lib/router";
+import { technicalSheetsRouter } from "@/app/admin/technical-sheets/_lib/router";
+import { templateTasksRouter } from "@/app/admin/template-tasks/_lib/router";
+import { templatesRouter } from "@/app/admin/templates/_lib/router";
+import { storageRouter } from "../storage/router";
+
+export const appRouter = {
+  assignments: assignmentsRouter,
+  executions: executionsRouter,
+  addresses: addressesRouter,
+  contacts: contactsRouter,
+  drive: driveRouter,
+  storage: storageRouter,
+  projects: projectsRouter,
+  runs: runsRouter,
+  runTasks: runTasksRouter,
+  registrations: registrationsRouter,
+  customers: customersRouter,
+  clients: clientsRouter,
+  companies: companiesRouter,
+  employees: employeesRouter,
+  products: productsRouter,
+  productImages: productImagesRouter,
+  tasks: tasksRouter,
+  emails: emailsRouter,
+  subprojects: subprojectsRouter,
+  purchaseOrderItems: purchaseOrderItemsRouter,
+  purchaseOrders: purchaseOrdersRouter,
+  suppliers: suppliersRouter,
+  quotations: quotationsRouter,
+  quotationItems: quotationItemsRouter,
+  salesOrders: salesOrdersRouter,
+  salesOrderItems: salesOrderItemsRouter,
+  salesOrderExecutions: salesOrderExecutionsRouter,
+  salesInvoices: salesInvoicesRouter,
+  salesInvoiceItems: salesInvoiceItemsRouter,
+  technicalSheets: technicalSheetsRouter,
+  templates: templatesRouter,
+  templateTasks: templateTasksRouter,
+};
+
+// export type definition of API
+export type AppRouter = typeof appRouter;
+export type RouterOutputs = InferRouterOutputs<AppRouter>;
+export type RouterInputs = InferRouterInputs<AppRouter>;

package/dist/templates/spark/src/server/storage/client.ts

@@ -0,0 +1,18 @@
+import { createUploadClient } from "@tulip-systems/storage/client";
+import { orpc } from "../router/client";
+
+/**
+ * Uplaod client
+ */
+export const uploadClient = createUploadClient({
+  endpoints: {
+    presign: (input) => orpc.storage.presign.call(input),
+    confirm: (uploadId) => orpc.storage.confirm.call(uploadId),
+    deleteAsset: (id) => orpc.storage.deleteAsset.call(id),
+    deleteAssets: (ids) => orpc.storage.deleteAssets.call(ids),
+    restoreAsset: (id) => orpc.storage.restoreAsset.call(id),
+    restoreAssets: (ids) => orpc.storage.restoreAssets.call(ids),
+    purgeAsset: (id) => orpc.storage.purgeAsset.call(id),
+    purgeAssets: (ids) => orpc.storage.purgeAssets.call(ids),
+  },
+});

package/dist/templates/spark/src/server/storage/init.ts

@@ -0,0 +1,19 @@
+import { storageDrizzleAdapter } from "@tulip-systems/storage/drizzle";
+import { storageS3Adapter } from "@tulip-systems/storage/s3";
+import { Storage } from "@tulip-systems/storage/server";
+import { env } from "@/env";
+import { db } from "../db/init";
+import * as schema from "./schema";
+
+export const storage = Storage.init({
+  database: storageDrizzleAdapter({ db, schema }),
+  adapter: storageS3Adapter({
+    bucketName: env.S3_BUCKET,
+    region: "auto",
+    endpoint: env.S3_ENDPOINT,
+    credentials: {
+      accessKeyId: env.S3_ACCESS_KEY_ID,
+      secretAccessKey: env.S3_SECRET_ACCESS_KEY,
+    },
+  }),
+});

package/dist/templates/spark/src/server/storage/router.ts

@@ -0,0 +1,38 @@
+import { implement } from "@orpc/server";
+import { storageRouterContract } from "@tulip-systems/storage/server";
+import type { RPCContext } from "../router/init";
+import { sessionMiddleware } from "../router/middleware";
+import { storage } from "./init";
+
+/**
+ * Storage procedure with session middleware applied
+ */
+export const storageProcedure = implement(storageRouterContract)
+  .$context<RPCContext>()
+  .use(sessionMiddleware);
+
+/**
+ * Storage router defines the procedures for handling storage-related operations such as presigning uploads, confirming uploads, deleting assets, restoring assets, and purging assets.
+ * Each procedure is implemented with the corresponding handler that interacts with the storage service.
+ * The procedures are protected by session middleware to ensure that only authenticated users can access them.
+ */
+export const storageRouter = {
+  presign: storageProcedure.presign.handler(async ({ input }) => storage.presignUpload(input)),
+  confirm: storageProcedure.confirm.handler(async ({ input }) => storage.confirmUpload(input)),
+  deleteAsset: storageProcedure.deleteAsset.handler(async ({ input }) =>
+    storage.deleteAsset(input),
+  ),
+  deleteAssets: storageProcedure.deleteAssets.handler(async ({ input }) =>
+    storage.deleteAssets(input),
+  ),
+  restoreAsset: storageProcedure.restoreAsset.handler(async ({ input }) =>
+    storage.restoreAsset(input),
+  ),
+  restoreAssets: storageProcedure.restoreAssets.handler(async ({ input }) =>
+    storage.restoreAssets(input),
+  ),
+  purgeAsset: storageProcedure.purgeAsset.handler(async ({ input }) => storage.purgeAsset(input)),
+  purgeAssets: storageProcedure.purgeAssets.handler(async ({ input }) =>
+    storage.purgeAssets(input),
+  ),
+};

package/dist/templates/spark/src/server/storage/schema.ts

@@ -0,0 +1,32 @@
+import { storageAdapterKeys } from "@tulip-systems/storage";
+import { index, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+import { baseColumns } from "../db/helpers";
+
+export const storageAssetStatusEnum = pgEnum("storage_asset_status", ["pending", "ready", "error"]);
+export const storageAssetVisibilityEnum = pgEnum("storage_asset_visibility", ["private", "public"]);
+
+export const storageAssets = pgTable(
+  "storage_assets",
+  (t) => ({
+    ...baseColumns,
+    provider: t.text({ enum: storageAdapterKeys }).notNull(),
+    bucket: t.text().notNull(),
+    key: t.text().notNull(),
+    status: storageAssetStatusEnum().notNull(),
+    visibility: storageAssetVisibilityEnum().notNull().default("private"),
+    size: t.integer().default(0),
+    contentType: t.varchar({ length: 255 }),
+    uploadId: t.uuid().notNull().defaultRandom(),
+    name: t.text(),
+    metadata: t.jsonb().$type<Record<string, unknown>>(),
+    etag: t.text(),
+    uploadedAt: t.timestamp().defaultNow().notNull(),
+    deletedAt: t.timestamp(),
+  }),
+  (t) => [
+    unique("storage_assets_upload_id_unique").on(t.uploadId),
+    unique("storage_assets_provider_bucket_key_unique").on(t.provider, t.bucket, t.key),
+    index("storage_assets_status_idx").on(t.status),
+    index("storage_assets_bucket_key_idx").on(t.bucket, t.key),
+  ],
+);

package/dist/templates/spark/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "declaration": false,
+    "declarationMap": false,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "next-env.d.ts",
+    "next.config.ts",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@tulip-systems/create-app",
+  "version": "0.11.1",
+  "type": "module",
+  "sideEffects": false,
+  "license": "AGPL-3.0",
+  "bin": {
+    "create-tulip-app": "./dist/index.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0",
+    "commander": "^14.0.3",
+    "publint": "^0.3.23",
+    "tsdown": "^0.22.14",
+    "typescript": "5.9.3",
+    "unrun": "^0.3.1",
+    "vitest": "^4.1.10",
+    "@tulip-systems/typescript-config": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "24.x"
+  },
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "scripts": {
+    "dev": "pnpm run build:templates && tsdown --config tsdown.config.ts --config-loader unrun --watch --no-clean",
+    "build": "pnpm run build:templates && tsdown --config tsdown.config.ts --config-loader unrun --no-clean",
+    "build:templates": "node scripts/build-templates.mjs",
+    "build:release": "pnpm run build:templates && tsdown --config tsdown.config.ts --config-loader unrun",
+    "lint": "biome check",
+    "typecheck": "tsc --noEmit",
+    "test:ci": "vitest run --passWithNoTests",
+    "format": "biome format --write"
+  }
+}